1//===------- TreeTransform.h - Semantic Tree Transformation -----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//===----------------------------------------------------------------------===//
7//
8// This file implements a semantic tree transformation that takes a given
9// AST and rebuilds it, possibly transforming some nodes in the process.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
14#define LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
15
16#include "CoroutineStmtBuilder.h"
17#include "TypeLocBuilder.h"
18#include "clang/AST/Decl.h"
19#include "clang/AST/DeclObjC.h"
20#include "clang/AST/DeclTemplate.h"
21#include "clang/AST/Expr.h"
22#include "clang/AST/ExprConcepts.h"
23#include "clang/AST/ExprCXX.h"
24#include "clang/AST/ExprObjC.h"
25#include "clang/AST/ExprOpenMP.h"
26#include "clang/AST/OpenMPClause.h"
27#include "clang/AST/Stmt.h"
28#include "clang/AST/StmtCXX.h"
29#include "clang/AST/StmtObjC.h"
30#include "clang/AST/StmtOpenMP.h"
31#include "clang/Basic/DiagnosticParse.h"
32#include "clang/Basic/OpenMPKinds.h"
33#include "clang/Sema/Designator.h"
34#include "clang/Sema/Lookup.h"
35#include "clang/Sema/Ownership.h"
36#include "clang/Sema/ParsedTemplate.h"
37#include "clang/Sema/ScopeInfo.h"
38#include "clang/Sema/SemaDiagnostic.h"
39#include "clang/Sema/SemaInternal.h"
40#include "llvm/ADT/ArrayRef.h"
41#include "llvm/Support/ErrorHandling.h"
42#include <algorithm>
43
44using namespace llvm::omp;
45
46namespace clang {
47using namespace sema;
48
49/// A semantic tree transformation that allows one to transform one
50/// abstract syntax tree into another.
51///
52/// A new tree transformation is defined by creating a new subclass \c X of
53/// \c TreeTransform<X> and then overriding certain operations to provide
54/// behavior specific to that transformation. For example, template
55/// instantiation is implemented as a tree transformation where the
56/// transformation of TemplateTypeParmType nodes involves substituting the
57/// template arguments for their corresponding template parameters; a similar
58/// transformation is performed for non-type template parameters and
59/// template template parameters.
60///
61/// This tree-transformation template uses static polymorphism to allow
62/// subclasses to customize any of its operations. Thus, a subclass can
63/// override any of the transformation or rebuild operators by providing an
64/// operation with the same signature as the default implementation. The
65/// overriding function should not be virtual.
66///
67/// Semantic tree transformations are split into two stages, either of which
68/// can be replaced by a subclass. The "transform" step transforms an AST node
69/// or the parts of an AST node using the various transformation functions,
70/// then passes the pieces on to the "rebuild" step, which constructs a new AST
71/// node of the appropriate kind from the pieces. The default transformation
72/// routines recursively transform the operands to composite AST nodes (e.g.,
73/// the pointee type of a PointerType node) and, if any of those operand nodes
74/// were changed by the transformation, invokes the rebuild operation to create
75/// a new AST node.
76///
77/// Subclasses can customize the transformation at various levels. The
78/// most coarse-grained transformations involve replacing TransformType(),
79/// TransformExpr(), TransformDecl(), TransformNestedNameSpecifierLoc(),
80/// TransformTemplateName(), or TransformTemplateArgument() with entirely
81/// new implementations.
82///
83/// For more fine-grained transformations, subclasses can replace any of the
84/// \c TransformXXX functions (where XXX is the name of an AST node, e.g.,
85/// PointerType, StmtExpr) to alter the transformation. As mentioned previously,
86/// replacing TransformTemplateTypeParmType() allows template instantiation
87/// to substitute template arguments for their corresponding template
88/// parameters. Additionally, subclasses can override the \c RebuildXXX
89/// functions to control how AST nodes are rebuilt when their operands change.
90/// By default, \c TreeTransform will invoke semantic analysis to rebuild
91/// AST nodes. However, certain other tree transformations (e.g, cloning) may
92/// be able to use more efficient rebuild steps.
93///
94/// There are a handful of other functions that can be overridden, allowing one
95/// to avoid traversing nodes that don't need any transformation
96/// (\c AlreadyTransformed()), force rebuilding AST nodes even when their
97/// operands have not changed (\c AlwaysRebuild()), and customize the
98/// default locations and entity names used for type-checking
99/// (\c getBaseLocation(), \c getBaseEntity()).
100template<typename Derived>
101class TreeTransform {
102 /// Private RAII object that helps us forget and then re-remember
103 /// the template argument corresponding to a partially-substituted parameter
104 /// pack.
105 class ForgetPartiallySubstitutedPackRAII {
106 Derived &Self;
107 TemplateArgument Old;
108
109 public:
110 ForgetPartiallySubstitutedPackRAII(Derived &Self) : Self(Self) {
111 Old = Self.ForgetPartiallySubstitutedPack();
112 }
113
114 ~ForgetPartiallySubstitutedPackRAII() {
115 Self.RememberPartiallySubstitutedPack(Old);
116 }
117 };
118
119protected:
120 Sema &SemaRef;
121
122 /// The set of local declarations that have been transformed, for
123 /// cases where we are forced to build new declarations within the transformer
124 /// rather than in the subclass (e.g., lambda closure types).
125 llvm::DenseMap<Decl *, Decl *> TransformedLocalDecls;
126
127public:
128 /// Initializes a new tree transformer.
129 TreeTransform(Sema &SemaRef) : SemaRef(SemaRef) { }
130
131 /// Retrieves a reference to the derived class.
132 Derived &getDerived() { return static_cast<Derived&>(*this); }
133
134 /// Retrieves a reference to the derived class.
135 const Derived &getDerived() const {
136 return static_cast<const Derived&>(*this);
137 }
138
139 static inline ExprResult Owned(Expr *E) { return E; }
140 static inline StmtResult Owned(Stmt *S) { return S; }
141
142 /// Retrieves a reference to the semantic analysis object used for
143 /// this tree transform.
144 Sema &getSema() const { return SemaRef; }
145
146 /// Whether the transformation should always rebuild AST nodes, even
147 /// if none of the children have changed.
148 ///
149 /// Subclasses may override this function to specify when the transformation
150 /// should rebuild all AST nodes.
151 ///
152 /// We must always rebuild all AST nodes when performing variadic template
153 /// pack expansion, in order to avoid violating the AST invariant that each
154 /// statement node appears at most once in its containing declaration.
155 bool AlwaysRebuild() { return SemaRef.ArgumentPackSubstitutionIndex != -1; }
156
157 /// Whether the transformation is forming an expression or statement that
158 /// replaces the original. In this case, we'll reuse mangling numbers from
159 /// existing lambdas.
160 bool ReplacingOriginal() { return false; }
161
162 /// Wether CXXConstructExpr can be skipped when they are implicit.
163 /// They will be reconstructed when used if needed.
164 /// This is usefull when the user that cause rebuilding of the
165 /// CXXConstructExpr is outside of the expression at which the TreeTransform
166 /// started.
167 bool AllowSkippingCXXConstructExpr() { return true; }
168
169 /// Returns the location of the entity being transformed, if that
170 /// information was not available elsewhere in the AST.
171 ///
172 /// By default, returns no source-location information. Subclasses can
173 /// provide an alternative implementation that provides better location
174 /// information.
175 SourceLocation getBaseLocation() { return SourceLocation(); }
176
177 /// Returns the name of the entity being transformed, if that
178 /// information was not available elsewhere in the AST.
179 ///
180 /// By default, returns an empty name. Subclasses can provide an alternative
181 /// implementation with a more precise name.
182 DeclarationName getBaseEntity() { return DeclarationName(); }
183
184 /// Sets the "base" location and entity when that
185 /// information is known based on another transformation.
186 ///
187 /// By default, the source location and entity are ignored. Subclasses can
188 /// override this function to provide a customized implementation.
189 void setBase(SourceLocation Loc, DeclarationName Entity) { }
190
191 /// RAII object that temporarily sets the base location and entity
192 /// used for reporting diagnostics in types.
193 class TemporaryBase {
194 TreeTransform &Self;
195 SourceLocation OldLocation;
196 DeclarationName OldEntity;
197
198 public:
199 TemporaryBase(TreeTransform &Self, SourceLocation Location,
200 DeclarationName Entity) : Self(Self) {
201 OldLocation = Self.getDerived().getBaseLocation();
202 OldEntity = Self.getDerived().getBaseEntity();
203
204 if (Location.isValid())
205 Self.getDerived().setBase(Location, Entity);
206 }
207
208 ~TemporaryBase() {
209 Self.getDerived().setBase(OldLocation, OldEntity);
210 }
211 };
212
213 /// Determine whether the given type \p T has already been
214 /// transformed.
215 ///
216 /// Subclasses can provide an alternative implementation of this routine
217 /// to short-circuit evaluation when it is known that a given type will
218 /// not change. For example, template instantiation need not traverse
219 /// non-dependent types.
220 bool AlreadyTransformed(QualType T) {
221 return T.isNull();
222 }
223
224 /// Transform a template parameter depth level.
225 ///
226 /// During a transformation that transforms template parameters, this maps
227 /// an old template parameter depth to a new depth.
228 unsigned TransformTemplateDepth(unsigned Depth) {
229 return Depth;
230 }
231
232 /// Determine whether the given call argument should be dropped, e.g.,
233 /// because it is a default argument.
234 ///
235 /// Subclasses can provide an alternative implementation of this routine to
236 /// determine which kinds of call arguments get dropped. By default,
237 /// CXXDefaultArgument nodes are dropped (prior to transformation).
238 bool DropCallArgument(Expr *E) {
239 return E->isDefaultArgument();
240 }
241
242 /// Determine whether we should expand a pack expansion with the
243 /// given set of parameter packs into separate arguments by repeatedly
244 /// transforming the pattern.
245 ///
246 /// By default, the transformer never tries to expand pack expansions.
247 /// Subclasses can override this routine to provide different behavior.
248 ///
249 /// \param EllipsisLoc The location of the ellipsis that identifies the
250 /// pack expansion.
251 ///
252 /// \param PatternRange The source range that covers the entire pattern of
253 /// the pack expansion.
254 ///
255 /// \param Unexpanded The set of unexpanded parameter packs within the
256 /// pattern.
257 ///
258 /// \param ShouldExpand Will be set to \c true if the transformer should
259 /// expand the corresponding pack expansions into separate arguments. When
260 /// set, \c NumExpansions must also be set.
261 ///
262 /// \param RetainExpansion Whether the caller should add an unexpanded
263 /// pack expansion after all of the expanded arguments. This is used
264 /// when extending explicitly-specified template argument packs per
265 /// C++0x [temp.arg.explicit]p9.
266 ///
267 /// \param NumExpansions The number of separate arguments that will be in
268 /// the expanded form of the corresponding pack expansion. This is both an
269 /// input and an output parameter, which can be set by the caller if the
270 /// number of expansions is known a priori (e.g., due to a prior substitution)
271 /// and will be set by the callee when the number of expansions is known.
272 /// The callee must set this value when \c ShouldExpand is \c true; it may
273 /// set this value in other cases.
274 ///
275 /// \returns true if an error occurred (e.g., because the parameter packs
276 /// are to be instantiated with arguments of different lengths), false
277 /// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions)
278 /// must be set.
279 bool TryExpandParameterPacks(SourceLocation EllipsisLoc,
280 SourceRange PatternRange,
281 ArrayRef<UnexpandedParameterPack> Unexpanded,
282 bool &ShouldExpand,
283 bool &RetainExpansion,
284 Optional<unsigned> &NumExpansions) {
285 ShouldExpand = false;
286 return false;
287 }
288
289 /// "Forget" about the partially-substituted pack template argument,
290 /// when performing an instantiation that must preserve the parameter pack
291 /// use.
292 ///
293 /// This routine is meant to be overridden by the template instantiator.
294 TemplateArgument ForgetPartiallySubstitutedPack() {
295 return TemplateArgument();
296 }
297
298 /// "Remember" the partially-substituted pack template argument
299 /// after performing an instantiation that must preserve the parameter pack
300 /// use.
301 ///
302 /// This routine is meant to be overridden by the template instantiator.
303 void RememberPartiallySubstitutedPack(TemplateArgument Arg) { }
304
305 /// Note to the derived class when a function parameter pack is
306 /// being expanded.
307 void ExpandingFunctionParameterPack(ParmVarDecl *Pack) { }
308
309 /// Transforms the given type into another type.
310 ///
311 /// By default, this routine transforms a type by creating a
312 /// TypeSourceInfo for it and delegating to the appropriate
313 /// function. This is expensive, but we don't mind, because
314 /// this method is deprecated anyway; all users should be
315 /// switched to storing TypeSourceInfos.
316 ///
317 /// \returns the transformed type.
318 QualType TransformType(QualType T);
319
320 /// Transforms the given type-with-location into a new
321 /// type-with-location.
322 ///
323 /// By default, this routine transforms a type by delegating to the
324 /// appropriate TransformXXXType to build a new type. Subclasses
325 /// may override this function (to take over all type
326 /// transformations) or some set of the TransformXXXType functions
327 /// to alter the transformation.
328 TypeSourceInfo *TransformType(TypeSourceInfo *DI);
329
330 /// Transform the given type-with-location into a new
331 /// type, collecting location information in the given builder
332 /// as necessary.
333 ///
334 QualType TransformType(TypeLocBuilder &TLB, TypeLoc TL);
335
336 /// Transform a type that is permitted to produce a
337 /// DeducedTemplateSpecializationType.
338 ///
339 /// This is used in the (relatively rare) contexts where it is acceptable
340 /// for transformation to produce a class template type with deduced
341 /// template arguments.
342 /// @{
343 QualType TransformTypeWithDeducedTST(QualType T);
344 TypeSourceInfo *TransformTypeWithDeducedTST(TypeSourceInfo *DI);
345 /// @}
346
347 /// The reason why the value of a statement is not discarded, if any.
348 enum StmtDiscardKind {
349 SDK_Discarded,
350 SDK_NotDiscarded,
351 SDK_StmtExprResult,
352 };
353
354 /// Transform the given statement.
355 ///
356 /// By default, this routine transforms a statement by delegating to the
357 /// appropriate TransformXXXStmt function to transform a specific kind of
358 /// statement or the TransformExpr() function to transform an expression.
359 /// Subclasses may override this function to transform statements using some
360 /// other mechanism.
361 ///
362 /// \returns the transformed statement.
363 StmtResult TransformStmt(Stmt *S, StmtDiscardKind SDK = SDK_Discarded);
364
365 /// Transform the given statement.
366 ///
367 /// By default, this routine transforms a statement by delegating to the
368 /// appropriate TransformOMPXXXClause function to transform a specific kind
369 /// of clause. Subclasses may override this function to transform statements
370 /// using some other mechanism.
371 ///
372 /// \returns the transformed OpenMP clause.
373 OMPClause *TransformOMPClause(OMPClause *S);
374
375 /// Transform the given attribute.
376 ///
377 /// By default, this routine transforms a statement by delegating to the
378 /// appropriate TransformXXXAttr function to transform a specific kind
379 /// of attribute. Subclasses may override this function to transform
380 /// attributed statements using some other mechanism.
381 ///
382 /// \returns the transformed attribute
383 const Attr *TransformAttr(const Attr *S);
384
385/// Transform the specified attribute.
386///
387/// Subclasses should override the transformation of attributes with a pragma
388/// spelling to transform expressions stored within the attribute.
389///
390/// \returns the transformed attribute.
391#define ATTR(X)
392#define PRAGMA_SPELLING_ATTR(X) \
393 const X##Attr *Transform##X##Attr(const X##Attr *R) { return R; }
394#include "clang/Basic/AttrList.inc"
395
396 /// Transform the given expression.
397 ///
398 /// By default, this routine transforms an expression by delegating to the
399 /// appropriate TransformXXXExpr function to build a new expression.
400 /// Subclasses may override this function to transform expressions using some
401 /// other mechanism.
402 ///
403 /// \returns the transformed expression.
404 ExprResult TransformExpr(Expr *E);
405
406 /// Transform the given initializer.
407 ///
408 /// By default, this routine transforms an initializer by stripping off the
409 /// semantic nodes added by initialization, then passing the result to
410 /// TransformExpr or TransformExprs.
411 ///
412 /// \returns the transformed initializer.
413 ExprResult TransformInitializer(Expr *Init, bool NotCopyInit);
414
415 /// Transform the given list of expressions.
416 ///
417 /// This routine transforms a list of expressions by invoking
418 /// \c TransformExpr() for each subexpression. However, it also provides
419 /// support for variadic templates by expanding any pack expansions (if the
420 /// derived class permits such expansion) along the way. When pack expansions
421 /// are present, the number of outputs may not equal the number of inputs.
422 ///
423 /// \param Inputs The set of expressions to be transformed.
424 ///
425 /// \param NumInputs The number of expressions in \c Inputs.
426 ///
427 /// \param IsCall If \c true, then this transform is being performed on
428 /// function-call arguments, and any arguments that should be dropped, will
429 /// be.
430 ///
431 /// \param Outputs The transformed input expressions will be added to this
432 /// vector.
433 ///
434 /// \param ArgChanged If non-NULL, will be set \c true if any argument changed
435 /// due to transformation.
436 ///
437 /// \returns true if an error occurred, false otherwise.
438 bool TransformExprs(Expr *const *Inputs, unsigned NumInputs, bool IsCall,
439 SmallVectorImpl<Expr *> &Outputs,
440 bool *ArgChanged = nullptr);
441
442 /// Transform the given declaration, which is referenced from a type
443 /// or expression.
444 ///
445 /// By default, acts as the identity function on declarations, unless the
446 /// transformer has had to transform the declaration itself. Subclasses
447 /// may override this function to provide alternate behavior.
448 Decl *TransformDecl(SourceLocation Loc, Decl *D) {
449 llvm::DenseMap<Decl *, Decl *>::iterator Known
450 = TransformedLocalDecls.find(D);
451 if (Known != TransformedLocalDecls.end())
452 return Known->second;
453
454 return D;
455 }
456
457 /// Transform the specified condition.
458 ///
459 /// By default, this transforms the variable and expression and rebuilds
460 /// the condition.
461 Sema::ConditionResult TransformCondition(SourceLocation Loc, VarDecl *Var,
462 Expr *Expr,
463 Sema::ConditionKind Kind);
464
465 /// Transform the attributes associated with the given declaration and
466 /// place them on the new declaration.
467 ///
468 /// By default, this operation does nothing. Subclasses may override this
469 /// behavior to transform attributes.
470 void transformAttrs(Decl *Old, Decl *New) { }
471
472 /// Note that a local declaration has been transformed by this
473 /// transformer.
474 ///
475 /// Local declarations are typically transformed via a call to
476 /// TransformDefinition. However, in some cases (e.g., lambda expressions),
477 /// the transformer itself has to transform the declarations. This routine
478 /// can be overridden by a subclass that keeps track of such mappings.
479 void transformedLocalDecl(Decl *Old, ArrayRef<Decl *> New) {
480 assert(New.size() == 1 &&
481 "must override transformedLocalDecl if performing pack expansion");
482 TransformedLocalDecls[Old] = New.front();
483 }
484
485 /// Transform the definition of the given declaration.
486 ///
487 /// By default, invokes TransformDecl() to transform the declaration.
488 /// Subclasses may override this function to provide alternate behavior.
489 Decl *TransformDefinition(SourceLocation Loc, Decl *D) {
490 return getDerived().TransformDecl(Loc, D);
491 }
492
493 /// Transform the given declaration, which was the first part of a
494 /// nested-name-specifier in a member access expression.
495 ///
496 /// This specific declaration transformation only applies to the first
497 /// identifier in a nested-name-specifier of a member access expression, e.g.,
498 /// the \c T in \c x->T::member
499 ///
500 /// By default, invokes TransformDecl() to transform the declaration.
501 /// Subclasses may override this function to provide alternate behavior.
502 NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc) {
503 return cast_or_null<NamedDecl>(getDerived().TransformDecl(Loc, D));
504 }
505
506 /// Transform the set of declarations in an OverloadExpr.
507 bool TransformOverloadExprDecls(OverloadExpr *Old, bool RequiresADL,
508 LookupResult &R);
509
510 /// Transform the given nested-name-specifier with source-location
511 /// information.
512 ///
513 /// By default, transforms all of the types and declarations within the
514 /// nested-name-specifier. Subclasses may override this function to provide
515 /// alternate behavior.
516 NestedNameSpecifierLoc
517 TransformNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
518 QualType ObjectType = QualType(),
519 NamedDecl *FirstQualifierInScope = nullptr);
520
521 /// Transform the given declaration name.
522 ///
523 /// By default, transforms the types of conversion function, constructor,
524 /// and destructor names and then (if needed) rebuilds the declaration name.
525 /// Identifiers and selectors are returned unmodified. Sublcasses may
526 /// override this function to provide alternate behavior.
527 DeclarationNameInfo
528 TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo);
529
530 bool TransformRequiresExprRequirements(ArrayRef<concepts::Requirement *> Reqs,
531 llvm::SmallVectorImpl<concepts::Requirement *> &Transformed);
532 concepts::TypeRequirement *
533 TransformTypeRequirement(concepts::TypeRequirement *Req);
534 concepts::ExprRequirement *
535 TransformExprRequirement(concepts::ExprRequirement *Req);
536 concepts::NestedRequirement *
537 TransformNestedRequirement(concepts::NestedRequirement *Req);
538
539 /// Transform the given template name.
540 ///
541 /// \param SS The nested-name-specifier that qualifies the template
542 /// name. This nested-name-specifier must already have been transformed.
543 ///
544 /// \param Name The template name to transform.
545 ///
546 /// \param NameLoc The source location of the template name.
547 ///
548 /// \param ObjectType If we're translating a template name within a member
549 /// access expression, this is the type of the object whose member template
550 /// is being referenced.
551 ///
552 /// \param FirstQualifierInScope If the first part of a nested-name-specifier
553 /// also refers to a name within the current (lexical) scope, this is the
554 /// declaration it refers to.
555 ///
556 /// By default, transforms the template name by transforming the declarations
557 /// and nested-name-specifiers that occur within the template name.
558 /// Subclasses may override this function to provide alternate behavior.
559 TemplateName
560 TransformTemplateName(CXXScopeSpec &SS, TemplateName Name,
561 SourceLocation NameLoc,
562 QualType ObjectType = QualType(),
563 NamedDecl *FirstQualifierInScope = nullptr,
564 bool AllowInjectedClassName = false);
565
566 /// Transform the given template argument.
567 ///
568 /// By default, this operation transforms the type, expression, or
569 /// declaration stored within the template argument and constructs a
570 /// new template argument from the transformed result. Subclasses may
571 /// override this function to provide alternate behavior.
572 ///
573 /// Returns true if there was an error.
574 bool TransformTemplateArgument(const TemplateArgumentLoc &Input,
575 TemplateArgumentLoc &Output,
576 bool Uneval = false);
577
578 /// Transform the given set of template arguments.
579 ///
580 /// By default, this operation transforms all of the template arguments
581 /// in the input set using \c TransformTemplateArgument(), and appends
582 /// the transformed arguments to the output list.
583 ///
584 /// Note that this overload of \c TransformTemplateArguments() is merely
585 /// a convenience function. Subclasses that wish to override this behavior
586 /// should override the iterator-based member template version.
587 ///
588 /// \param Inputs The set of template arguments to be transformed.
589 ///
590 /// \param NumInputs The number of template arguments in \p Inputs.
591 ///
592 /// \param Outputs The set of transformed template arguments output by this
593 /// routine.
594 ///
595 /// Returns true if an error occurred.
596 bool TransformTemplateArguments(const TemplateArgumentLoc *Inputs,
597 unsigned NumInputs,
598 TemplateArgumentListInfo &Outputs,
599 bool Uneval = false) {
600 return TransformTemplateArguments(Inputs, Inputs + NumInputs, Outputs,
601 Uneval);
602 }
603
604 /// Transform the given set of template arguments.
605 ///
606 /// By default, this operation transforms all of the template arguments
607 /// in the input set using \c TransformTemplateArgument(), and appends
608 /// the transformed arguments to the output list.
609 ///
610 /// \param First An iterator to the first template argument.
611 ///
612 /// \param Last An iterator one step past the last template argument.
613 ///
614 /// \param Outputs The set of transformed template arguments output by this
615 /// routine.
616 ///
617 /// Returns true if an error occurred.
618 template<typename InputIterator>
619 bool TransformTemplateArguments(InputIterator First,
620 InputIterator Last,
621 TemplateArgumentListInfo &Outputs,
622 bool Uneval = false);
623
624 /// Fakes up a TemplateArgumentLoc for a given TemplateArgument.
625 void InventTemplateArgumentLoc(const TemplateArgument &Arg,
626 TemplateArgumentLoc &ArgLoc);
627
628 /// Fakes up a TypeSourceInfo for a type.
629 TypeSourceInfo *InventTypeSourceInfo(QualType T) {
630 return SemaRef.Context.getTrivialTypeSourceInfo(T,
631 getDerived().getBaseLocation());
632 }
633
634#define ABSTRACT_TYPELOC(CLASS, PARENT)
635#define TYPELOC(CLASS, PARENT) \
636 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
637#include "clang/AST/TypeLocNodes.def"
638
639 template<typename Fn>
640 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
641 FunctionProtoTypeLoc TL,
642 CXXRecordDecl *ThisContext,
643 Qualifiers ThisTypeQuals,
644 Fn TransformExceptionSpec);
645
646 bool TransformExceptionSpec(SourceLocation Loc,
647 FunctionProtoType::ExceptionSpecInfo &ESI,
648 SmallVectorImpl<QualType> &Exceptions,
649 bool &Changed);
650
651 StmtResult TransformSEHHandler(Stmt *Handler);
652
653 QualType
654 TransformTemplateSpecializationType(TypeLocBuilder &TLB,
655 TemplateSpecializationTypeLoc TL,
656 TemplateName Template);
657
658 QualType
659 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
660 DependentTemplateSpecializationTypeLoc TL,
661 TemplateName Template,
662 CXXScopeSpec &SS);
663
664 QualType TransformDependentTemplateSpecializationType(
665 TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL,
666 NestedNameSpecifierLoc QualifierLoc);
667
668 /// Transforms the parameters of a function type into the
669 /// given vectors.
670 ///
671 /// The result vectors should be kept in sync; null entries in the
672 /// variables vector are acceptable.
673 ///
674 /// Return true on error.
675 bool TransformFunctionTypeParams(
676 SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
677 const QualType *ParamTypes,
678 const FunctionProtoType::ExtParameterInfo *ParamInfos,
679 SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl *> *PVars,
680 Sema::ExtParameterInfoBuilder &PInfos);
681
682 /// Transforms a single function-type parameter. Return null
683 /// on error.
684 ///
685 /// \param indexAdjustment - A number to add to the parameter's
686 /// scope index; can be negative
687 ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
688 int indexAdjustment,
689 Optional<unsigned> NumExpansions,
690 bool ExpectParameterPack);
691
692 /// Transform the body of a lambda-expression.
693 StmtResult TransformLambdaBody(LambdaExpr *E, Stmt *Body);
694 /// Alternative implementation of TransformLambdaBody that skips transforming
695 /// the body.
696 StmtResult SkipLambdaBody(LambdaExpr *E, Stmt *Body);
697
698 QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL);
699
700 StmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr);
701 ExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *E);
702
703 TemplateParameterList *TransformTemplateParameterList(
704 TemplateParameterList *TPL) {
705 return TPL;
706 }
707
708 ExprResult TransformAddressOfOperand(Expr *E);
709
710 ExprResult TransformDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E,
711 bool IsAddressOfOperand,
712 TypeSourceInfo **RecoveryTSI);
713
714 ExprResult TransformParenDependentScopeDeclRefExpr(
715 ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool IsAddressOfOperand,
716 TypeSourceInfo **RecoveryTSI);
717
718 StmtResult TransformOMPExecutableDirective(OMPExecutableDirective *S);
719
720// FIXME: We use LLVM_ATTRIBUTE_NOINLINE because inlining causes a ridiculous
721// amount of stack usage with clang.
722#define STMT(Node, Parent) \
723 LLVM_ATTRIBUTE_NOINLINE \
724 StmtResult Transform##Node(Node *S);
725#define VALUESTMT(Node, Parent) \
726 LLVM_ATTRIBUTE_NOINLINE \
727 StmtResult Transform##Node(Node *S, StmtDiscardKind SDK);
728#define EXPR(Node, Parent) \
729 LLVM_ATTRIBUTE_NOINLINE \
730 ExprResult Transform##Node(Node *E);
731#define ABSTRACT_STMT(Stmt)
732#include "clang/AST/StmtNodes.inc"
733
734#define GEN_CLANG_CLAUSE_CLASS
735#define CLAUSE_CLASS(Enum, Str, Class) \
736 LLVM_ATTRIBUTE_NOINLINE \
737 OMPClause *Transform##Class(Class *S);
738#include "llvm/Frontend/OpenMP/OMP.inc"
739
740 /// Build a new qualified type given its unqualified type and type location.
741 ///
742 /// By default, this routine adds type qualifiers only to types that can
743 /// have qualifiers, and silently suppresses those qualifiers that are not
744 /// permitted. Subclasses may override this routine to provide different
745 /// behavior.
746 QualType RebuildQualifiedType(QualType T, QualifiedTypeLoc TL);
747
748 /// Build a new pointer type given its pointee type.
749 ///
750 /// By default, performs semantic analysis when building the pointer type.
751 /// Subclasses may override this routine to provide different behavior.
752 QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil);
753
754 /// Build a new block pointer type given its pointee type.
755 ///
756 /// By default, performs semantic analysis when building the block pointer
757 /// type. Subclasses may override this routine to provide different behavior.
758 QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil);
759
760 /// Build a new reference type given the type it references.
761 ///
762 /// By default, performs semantic analysis when building the
763 /// reference type. Subclasses may override this routine to provide
764 /// different behavior.
765 ///
766 /// \param LValue whether the type was written with an lvalue sigil
767 /// or an rvalue sigil.
768 QualType RebuildReferenceType(QualType ReferentType,
769 bool LValue,
770 SourceLocation Sigil);
771
772 /// Build a new member pointer type given the pointee type and the
773 /// class type it refers into.
774 ///
775 /// By default, performs semantic analysis when building the member pointer
776 /// type. Subclasses may override this routine to provide different behavior.
777 QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType,
778 SourceLocation Sigil);
779
780 QualType RebuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,
781 SourceLocation ProtocolLAngleLoc,
782 ArrayRef<ObjCProtocolDecl *> Protocols,
783 ArrayRef<SourceLocation> ProtocolLocs,
784 SourceLocation ProtocolRAngleLoc);
785
786 /// Build an Objective-C object type.
787 ///
788 /// By default, performs semantic analysis when building the object type.
789 /// Subclasses may override this routine to provide different behavior.
790 QualType RebuildObjCObjectType(QualType BaseType,
791 SourceLocation Loc,
792 SourceLocation TypeArgsLAngleLoc,
793 ArrayRef<TypeSourceInfo *> TypeArgs,
794 SourceLocation TypeArgsRAngleLoc,
795 SourceLocation ProtocolLAngleLoc,
796 ArrayRef<ObjCProtocolDecl *> Protocols,
797 ArrayRef<SourceLocation> ProtocolLocs,
798 SourceLocation ProtocolRAngleLoc);
799
800 /// Build a new Objective-C object pointer type given the pointee type.
801 ///
802 /// By default, directly builds the pointer type, with no additional semantic
803 /// analysis.
804 QualType RebuildObjCObjectPointerType(QualType PointeeType,
805 SourceLocation Star);
806
807 /// Build a new array type given the element type, size
808 /// modifier, size of the array (if known), size expression, and index type
809 /// qualifiers.
810 ///
811 /// By default, performs semantic analysis when building the array type.
812 /// Subclasses may override this routine to provide different behavior.
813 /// Also by default, all of the other Rebuild*Array
814 QualType RebuildArrayType(QualType ElementType,
815 ArrayType::ArraySizeModifier SizeMod,
816 const llvm::APInt *Size,
817 Expr *SizeExpr,
818 unsigned IndexTypeQuals,
819 SourceRange BracketsRange);
820
821 /// Build a new constant array type given the element type, size
822 /// modifier, (known) size of the array, and index type qualifiers.
823 ///
824 /// By default, performs semantic analysis when building the array type.
825 /// Subclasses may override this routine to provide different behavior.
826 QualType RebuildConstantArrayType(QualType ElementType,
827 ArrayType::ArraySizeModifier SizeMod,
828 const llvm::APInt &Size,
829 Expr *SizeExpr,
830 unsigned IndexTypeQuals,
831 SourceRange BracketsRange);
832
833 /// Build a new incomplete array type given the element type, size
834 /// modifier, and index type qualifiers.
835 ///
836 /// By default, performs semantic analysis when building the array type.
837 /// Subclasses may override this routine to provide different behavior.
838 QualType RebuildIncompleteArrayType(QualType ElementType,
839 ArrayType::ArraySizeModifier SizeMod,
840 unsigned IndexTypeQuals,
841 SourceRange BracketsRange);
842
843 /// Build a new variable-length array type given the element type,
844 /// size modifier, size expression, and index type qualifiers.
845 ///
846 /// By default, performs semantic analysis when building the array type.
847 /// Subclasses may override this routine to provide different behavior.
848 QualType RebuildVariableArrayType(QualType ElementType,
849 ArrayType::ArraySizeModifier SizeMod,
850 Expr *SizeExpr,
851 unsigned IndexTypeQuals,
852 SourceRange BracketsRange);
853
854 /// Build a new dependent-sized array type given the element type,
855 /// size modifier, size expression, and index type qualifiers.
856 ///
857 /// By default, performs semantic analysis when building the array type.
858 /// Subclasses may override this routine to provide different behavior.
859 QualType RebuildDependentSizedArrayType(QualType ElementType,
860 ArrayType::ArraySizeModifier SizeMod,
861 Expr *SizeExpr,
862 unsigned IndexTypeQuals,
863 SourceRange BracketsRange);
864
865 /// Build a new vector type given the element type and
866 /// number of elements.
867 ///
868 /// By default, performs semantic analysis when building the vector type.
869 /// Subclasses may override this routine to provide different behavior.
870 QualType RebuildVectorType(QualType ElementType, unsigned NumElements,
871 VectorType::VectorKind VecKind);
872
873 /// Build a new potentially dependently-sized extended vector type
874 /// given the element type and number of elements.
875 ///
876 /// By default, performs semantic analysis when building the vector type.
877 /// Subclasses may override this routine to provide different behavior.
878 QualType RebuildDependentVectorType(QualType ElementType, Expr *SizeExpr,
879 SourceLocation AttributeLoc,
880 VectorType::VectorKind);
881
882 /// Build a new extended vector type given the element type and
883 /// number of elements.
884 ///
885 /// By default, performs semantic analysis when building the vector type.
886 /// Subclasses may override this routine to provide different behavior.
887 QualType RebuildExtVectorType(QualType ElementType, unsigned NumElements,
888 SourceLocation AttributeLoc);
889
890 /// Build a new potentially dependently-sized extended vector type
891 /// given the element type and number of elements.
892 ///
893 /// By default, performs semantic analysis when building the vector type.
894 /// Subclasses may override this routine to provide different behavior.
895 QualType RebuildDependentSizedExtVectorType(QualType ElementType,
896 Expr *SizeExpr,
897 SourceLocation AttributeLoc);
898
899 /// Build a new matrix type given the element type and dimensions.
900 QualType RebuildConstantMatrixType(QualType ElementType, unsigned NumRows,
901 unsigned NumColumns);
902
903 /// Build a new matrix type given the type and dependently-defined
904 /// dimensions.
905 QualType RebuildDependentSizedMatrixType(QualType ElementType, Expr *RowExpr,
906 Expr *ColumnExpr,
907 SourceLocation AttributeLoc);
908
909 /// Build a new DependentAddressSpaceType or return the pointee
910 /// type variable with the correct address space (retrieved from
911 /// AddrSpaceExpr) applied to it. The former will be returned in cases
912 /// where the address space remains dependent.
913 ///
914 /// By default, performs semantic analysis when building the type with address
915 /// space applied. Subclasses may override this routine to provide different
916 /// behavior.
917 QualType RebuildDependentAddressSpaceType(QualType PointeeType,
918 Expr *AddrSpaceExpr,
919 SourceLocation AttributeLoc);
920
921 /// Build a new function type.
922 ///
923 /// By default, performs semantic analysis when building the function type.
924 /// Subclasses may override this routine to provide different behavior.
925 QualType RebuildFunctionProtoType(QualType T,
926 MutableArrayRef<QualType> ParamTypes,
927 const FunctionProtoType::ExtProtoInfo &EPI);
928
929 /// Build a new unprototyped function type.
930 QualType RebuildFunctionNoProtoType(QualType ResultType);
931
932 /// Rebuild an unresolved typename type, given the decl that
933 /// the UnresolvedUsingTypenameDecl was transformed to.
934 QualType RebuildUnresolvedUsingType(SourceLocation NameLoc, Decl *D);
935
936 /// Build a new typedef type.
937 QualType RebuildTypedefType(TypedefNameDecl *Typedef) {
938 return SemaRef.Context.getTypeDeclType(Typedef);
939 }
940
941 /// Build a new MacroDefined type.
942 QualType RebuildMacroQualifiedType(QualType T,
943 const IdentifierInfo *MacroII) {
944 return SemaRef.Context.getMacroQualifiedType(T, MacroII);
945 }
946
947 /// Build a new class/struct/union type.
948 QualType RebuildRecordType(RecordDecl *Record) {
949 return SemaRef.Context.getTypeDeclType(Record);
950 }
951
952 /// Build a new Enum type.
953 QualType RebuildEnumType(EnumDecl *Enum) {
954 return SemaRef.Context.getTypeDeclType(Enum);
955 }
956
957 /// Build a new typeof(expr) type.
958 ///
959 /// By default, performs semantic analysis when building the typeof type.
960 /// Subclasses may override this routine to provide different behavior.
961 QualType RebuildTypeOfExprType(Expr *Underlying, SourceLocation Loc);
962
963 /// Build a new typeof(type) type.
964 ///
965 /// By default, builds a new TypeOfType with the given underlying type.
966 QualType RebuildTypeOfType(QualType Underlying);
967
968 /// Build a new unary transform type.
969 QualType RebuildUnaryTransformType(QualType BaseType,
970 UnaryTransformType::UTTKind UKind,
971 SourceLocation Loc);
972
973 /// Build a new C++11 decltype type.
974 ///
975 /// By default, performs semantic analysis when building the decltype type.
976 /// Subclasses may override this routine to provide different behavior.
977 QualType RebuildDecltypeType(Expr *Underlying, SourceLocation Loc);
978
979 /// Build a new C++11 auto type.
980 ///
981 /// By default, builds a new AutoType with the given deduced type.
982 QualType RebuildAutoType(QualType Deduced, AutoTypeKeyword Keyword,
983 ConceptDecl *TypeConstraintConcept,
984 ArrayRef<TemplateArgument> TypeConstraintArgs) {
985 // Note, IsDependent is always false here: we implicitly convert an 'auto'
986 // which has been deduced to a dependent type into an undeduced 'auto', so
987 // that we'll retry deduction after the transformation.
988 return SemaRef.Context.getAutoType(Deduced, Keyword,
989 /*IsDependent*/ false, /*IsPack=*/false,
990 TypeConstraintConcept,
991 TypeConstraintArgs);
992 }
993
994 /// By default, builds a new DeducedTemplateSpecializationType with the given
995 /// deduced type.
996 QualType RebuildDeducedTemplateSpecializationType(TemplateName Template,
997 QualType Deduced) {
998 return SemaRef.Context.getDeducedTemplateSpecializationType(
999 Template, Deduced, /*IsDependent*/ false);
1000 }
1001
1002 /// Build a new template specialization type.
1003 ///
1004 /// By default, performs semantic analysis when building the template
1005 /// specialization type. Subclasses may override this routine to provide
1006 /// different behavior.
1007 QualType RebuildTemplateSpecializationType(TemplateName Template,
1008 SourceLocation TemplateLoc,
1009 TemplateArgumentListInfo &Args);
1010
1011 /// Build a new parenthesized type.
1012 ///
1013 /// By default, builds a new ParenType type from the inner type.
1014 /// Subclasses may override this routine to provide different behavior.
1015 QualType RebuildParenType(QualType InnerType) {
1016 return SemaRef.BuildParenType(InnerType);
1017 }
1018
1019 /// Build a new qualified name type.
1020 ///
1021 /// By default, builds a new ElaboratedType type from the keyword,
1022 /// the nested-name-specifier and the named type.
1023 /// Subclasses may override this routine to provide different behavior.
1024 QualType RebuildElaboratedType(SourceLocation KeywordLoc,
1025 ElaboratedTypeKeyword Keyword,
1026 NestedNameSpecifierLoc QualifierLoc,
1027 QualType Named) {
1028 return SemaRef.Context.getElaboratedType(Keyword,
1029 QualifierLoc.getNestedNameSpecifier(),
1030 Named);
1031 }
1032
1033 /// Build a new typename type that refers to a template-id.
1034 ///
1035 /// By default, builds a new DependentNameType type from the
1036 /// nested-name-specifier and the given type. Subclasses may override
1037 /// this routine to provide different behavior.
1038 QualType RebuildDependentTemplateSpecializationType(
1039 ElaboratedTypeKeyword Keyword,
1040 NestedNameSpecifierLoc QualifierLoc,
1041 SourceLocation TemplateKWLoc,
1042 const IdentifierInfo *Name,
1043 SourceLocation NameLoc,
1044 TemplateArgumentListInfo &Args,
1045 bool AllowInjectedClassName) {
1046 // Rebuild the template name.
1047 // TODO: avoid TemplateName abstraction
1048 CXXScopeSpec SS;
1049 SS.Adopt(QualifierLoc);
1050 TemplateName InstName = getDerived().RebuildTemplateName(
1051 SS, TemplateKWLoc, *Name, NameLoc, QualType(), nullptr,
1052 AllowInjectedClassName);
1053
1054 if (InstName.isNull())
1055 return QualType();
1056
1057 // If it's still dependent, make a dependent specialization.
1058 if (InstName.getAsDependentTemplateName())
1059 return SemaRef.Context.getDependentTemplateSpecializationType(Keyword,
1060 QualifierLoc.getNestedNameSpecifier(),
1061 Name,
1062 Args);
1063
1064 // Otherwise, make an elaborated type wrapping a non-dependent
1065 // specialization.
1066 QualType T =
1067 getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
1068 if (T.isNull()) return QualType();
1069
1070 if (Keyword == ETK_None && QualifierLoc.getNestedNameSpecifier() == nullptr)
1071 return T;
1072
1073 return SemaRef.Context.getElaboratedType(Keyword,
1074 QualifierLoc.getNestedNameSpecifier(),
1075 T);
1076 }
1077
1078 /// Build a new typename type that refers to an identifier.
1079 ///
1080 /// By default, performs semantic analysis when building the typename type
1081 /// (or elaborated type). Subclasses may override this routine to provide
1082 /// different behavior.
1083 QualType RebuildDependentNameType(ElaboratedTypeKeyword Keyword,
1084 SourceLocation KeywordLoc,
1085 NestedNameSpecifierLoc QualifierLoc,
1086 const IdentifierInfo *Id,
1087 SourceLocation IdLoc,
1088 bool DeducedTSTContext) {
1089 CXXScopeSpec SS;
1090 SS.Adopt(QualifierLoc);
1091
1092 if (QualifierLoc.getNestedNameSpecifier()->isDependent()) {
1093 // If the name is still dependent, just build a new dependent name type.
1094 if (!SemaRef.computeDeclContext(SS))
1095 return SemaRef.Context.getDependentNameType(Keyword,
1096 QualifierLoc.getNestedNameSpecifier(),
1097 Id);
1098 }
1099
1100 if (Keyword == ETK_None || Keyword == ETK_Typename) {
1101 return SemaRef.CheckTypenameType(Keyword, KeywordLoc, QualifierLoc,
1102 *Id, IdLoc, DeducedTSTContext);
1103 }
1104
1105 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);
1106
1107 // We had a dependent elaborated-type-specifier that has been transformed
1108 // into a non-dependent elaborated-type-specifier. Find the tag we're
1109 // referring to.
1110 LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
1111 DeclContext *DC = SemaRef.computeDeclContext(SS, false);
1112 if (!DC)
1113 return QualType();
1114
1115 if (SemaRef.RequireCompleteDeclContext(SS, DC))
1116 return QualType();
1117
1118 TagDecl *Tag = nullptr;
1119 SemaRef.LookupQualifiedName(Result, DC);
1120 switch (Result.getResultKind()) {
1121 case LookupResult::NotFound:
1122 case LookupResult::NotFoundInCurrentInstantiation:
1123 break;
1124
1125 case LookupResult::Found:
1126 Tag = Result.getAsSingle<TagDecl>();
1127 break;
1128
1129 case LookupResult::FoundOverloaded:
1130 case LookupResult::FoundUnresolvedValue:
1131 llvm_unreachable("Tag lookup cannot find non-tags");
1132
1133 case LookupResult::Ambiguous:
1134 // Let the LookupResult structure handle ambiguities.
1135 return QualType();
1136 }
1137
1138 if (!Tag) {
1139 // Check where the name exists but isn't a tag type and use that to emit
1140 // better diagnostics.
1141 LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
1142 SemaRef.LookupQualifiedName(Result, DC);
1143 switch (Result.getResultKind()) {
1144 case LookupResult::Found:
1145 case LookupResult::FoundOverloaded:
1146 case LookupResult::FoundUnresolvedValue: {
1147 NamedDecl *SomeDecl = Result.getRepresentativeDecl();
1148 Sema::NonTagKind NTK = SemaRef.getNonTagTypeDeclKind(SomeDecl, Kind);
1149 SemaRef.Diag(IdLoc, diag::err_tag_reference_non_tag) << SomeDecl
1150 << NTK << Kind;
1151 SemaRef.Diag(SomeDecl->getLocation(), diag::note_declared_at);
1152 break;
1153 }
1154 default:
1155 SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope)
1156 << Kind << Id << DC << QualifierLoc.getSourceRange();
1157 break;
1158 }
1159 return QualType();
1160 }
1161
1162 if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind, /*isDefinition*/false,
1163 IdLoc, Id)) {
1164 SemaRef.Diag(KeywordLoc, diag::err_use_with_wrong_tag) << Id;
1165 SemaRef.Diag(Tag->getLocation(), diag::note_previous_use);
1166 return QualType();
1167 }
1168
1169 // Build the elaborated-type-specifier type.
1170 QualType T = SemaRef.Context.getTypeDeclType(Tag);
1171 return SemaRef.Context.getElaboratedType(Keyword,
1172 QualifierLoc.getNestedNameSpecifier(),
1173 T);
1174 }
1175
1176 /// Build a new pack expansion type.
1177 ///
1178 /// By default, builds a new PackExpansionType type from the given pattern.
1179 /// Subclasses may override this routine to provide different behavior.
1180 QualType RebuildPackExpansionType(QualType Pattern,
1181 SourceRange PatternRange,
1182 SourceLocation EllipsisLoc,
1183 Optional<unsigned> NumExpansions) {
1184 return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc,
1185 NumExpansions);
1186 }
1187
1188 /// Build a new atomic type given its value type.
1189 ///
1190 /// By default, performs semantic analysis when building the atomic type.
1191 /// Subclasses may override this routine to provide different behavior.
1192 QualType RebuildAtomicType(QualType ValueType, SourceLocation KWLoc);
1193
1194 /// Build a new pipe type given its value type.
1195 QualType RebuildPipeType(QualType ValueType, SourceLocation KWLoc,
1196 bool isReadPipe);
1197
1198 /// Build an extended int given its value type.
1199 QualType RebuildExtIntType(bool IsUnsigned, unsigned NumBits,
1200 SourceLocation Loc);
1201
1202 /// Build a dependent extended int given its value type.
1203 QualType RebuildDependentExtIntType(bool IsUnsigned, Expr *NumBitsExpr,
1204 SourceLocation Loc);
1205
1206 /// Build a new template name given a nested name specifier, a flag
1207 /// indicating whether the "template" keyword was provided, and the template
1208 /// that the template name refers to.
1209 ///
1210 /// By default, builds the new template name directly. Subclasses may override
1211 /// this routine to provide different behavior.
1212 TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1213 bool TemplateKW,
1214 TemplateDecl *Template);
1215
1216 /// Build a new template name given a nested name specifier and the
1217 /// name that is referred to as a template.
1218 ///
1219 /// By default, performs semantic analysis to determine whether the name can
1220 /// be resolved to a specific template, then builds the appropriate kind of
1221 /// template name. Subclasses may override this routine to provide different
1222 /// behavior.
1223 TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1224 SourceLocation TemplateKWLoc,
1225 const IdentifierInfo &Name,
1226 SourceLocation NameLoc, QualType ObjectType,
1227 NamedDecl *FirstQualifierInScope,
1228 bool AllowInjectedClassName);
1229
1230 /// Build a new template name given a nested name specifier and the
1231 /// overloaded operator name that is referred to as a template.
1232 ///
1233 /// By default, performs semantic analysis to determine whether the name can
1234 /// be resolved to a specific template, then builds the appropriate kind of
1235 /// template name. Subclasses may override this routine to provide different
1236 /// behavior.
1237 TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1238 SourceLocation TemplateKWLoc,
1239 OverloadedOperatorKind Operator,
1240 SourceLocation NameLoc, QualType ObjectType,
1241 bool AllowInjectedClassName);
1242
1243 /// Build a new template name given a template template parameter pack
1244 /// and the
1245 ///
1246 /// By default, performs semantic analysis to determine whether the name can
1247 /// be resolved to a specific template, then builds the appropriate kind of
1248 /// template name. Subclasses may override this routine to provide different
1249 /// behavior.
1250 TemplateName RebuildTemplateName(TemplateTemplateParmDecl *Param,
1251 const TemplateArgument &ArgPack) {
1252 return getSema().Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
1253 }
1254
1255 /// Build a new compound statement.
1256 ///
1257 /// By default, performs semantic analysis to build the new statement.
1258 /// Subclasses may override this routine to provide different behavior.
1259 StmtResult RebuildCompoundStmt(SourceLocation LBraceLoc,
1260 MultiStmtArg Statements,
1261 SourceLocation RBraceLoc,
1262 bool IsStmtExpr) {
1263 return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, Statements,
1264 IsStmtExpr);
1265 }
1266
1267 /// Build a new case statement.
1268 ///
1269 /// By default, performs semantic analysis to build the new statement.
1270 /// Subclasses may override this routine to provide different behavior.
1271 StmtResult RebuildCaseStmt(SourceLocation CaseLoc,
1272 Expr *LHS,
1273 SourceLocation EllipsisLoc,
1274 Expr *RHS,
1275 SourceLocation ColonLoc) {
1276 return getSema().ActOnCaseStmt(CaseLoc, LHS, EllipsisLoc, RHS,
1277 ColonLoc);
1278 }
1279
1280 /// Attach the body to a new case statement.
1281 ///
1282 /// By default, performs semantic analysis to build the new statement.
1283 /// Subclasses may override this routine to provide different behavior.
1284 StmtResult RebuildCaseStmtBody(Stmt *S, Stmt *Body) {
1285 getSema().ActOnCaseStmtBody(S, Body);
1286 return S;
1287 }
1288
1289 /// Build a new default statement.
1290 ///
1291 /// By default, performs semantic analysis to build the new statement.
1292 /// Subclasses may override this routine to provide different behavior.
1293 StmtResult RebuildDefaultStmt(SourceLocation DefaultLoc,
1294 SourceLocation ColonLoc,
1295 Stmt *SubStmt) {
1296 return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt,
1297 /*CurScope=*/nullptr);
1298 }
1299
1300 /// Build a new label statement.
1301 ///
1302 /// By default, performs semantic analysis to build the new statement.
1303 /// Subclasses may override this routine to provide different behavior.
1304 StmtResult RebuildLabelStmt(SourceLocation IdentLoc, LabelDecl *L,
1305 SourceLocation ColonLoc, Stmt *SubStmt) {
1306 return SemaRef.ActOnLabelStmt(IdentLoc, L, ColonLoc, SubStmt);
1307 }
1308
1309 /// Build a new attributed statement.
1310 ///
1311 /// By default, performs semantic analysis to build the new statement.
1312 /// Subclasses may override this routine to provide different behavior.
1313 StmtResult RebuildAttributedStmt(SourceLocation AttrLoc,
1314 ArrayRef<const Attr*> Attrs,
1315 Stmt *SubStmt) {
1316 return SemaRef.ActOnAttributedStmt(AttrLoc, Attrs, SubStmt);
1317 }
1318
1319 /// Build a new "if" statement.
1320 ///
1321 /// By default, performs semantic analysis to build the new statement.
1322 /// Subclasses may override this routine to provide different behavior.
1323 StmtResult RebuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,
1324 SourceLocation LParenLoc, Sema::ConditionResult Cond,
1325 SourceLocation RParenLoc, Stmt *Init, Stmt *Then,
1326 SourceLocation ElseLoc, Stmt *Else) {
1327 return getSema().ActOnIfStmt(IfLoc, IsConstexpr, LParenLoc, Init, Cond,
1328 RParenLoc, Then, ElseLoc, Else);
1329 }
1330
1331 /// Start building a new switch statement.
1332 ///
1333 /// By default, performs semantic analysis to build the new statement.
1334 /// Subclasses may override this routine to provide different behavior.
1335 StmtResult RebuildSwitchStmtStart(SourceLocation SwitchLoc,
1336 SourceLocation LParenLoc, Stmt *Init,
1337 Sema::ConditionResult Cond,
1338 SourceLocation RParenLoc) {
1339 return getSema().ActOnStartOfSwitchStmt(SwitchLoc, LParenLoc, Init, Cond,
1340 RParenLoc);
1341 }
1342
1343 /// Attach the body to the switch statement.
1344 ///
1345 /// By default, performs semantic analysis to build the new statement.
1346 /// Subclasses may override this routine to provide different behavior.
1347 StmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc,
1348 Stmt *Switch, Stmt *Body) {
1349 return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body);
1350 }
1351
1352 /// Build a new while statement.
1353 ///
1354 /// By default, performs semantic analysis to build the new statement.
1355 /// Subclasses may override this routine to provide different behavior.
1356 StmtResult RebuildWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc,
1357 Sema::ConditionResult Cond,
1358 SourceLocation RParenLoc, Stmt *Body) {
1359 return getSema().ActOnWhileStmt(WhileLoc, LParenLoc, Cond, RParenLoc, Body);
1360 }
1361
1362 /// Build a new do-while statement.
1363 ///
1364 /// By default, performs semantic analysis to build the new statement.
1365 /// Subclasses may override this routine to provide different behavior.
1366 StmtResult RebuildDoStmt(SourceLocation DoLoc, Stmt *Body,
1367 SourceLocation WhileLoc, SourceLocation LParenLoc,
1368 Expr *Cond, SourceLocation RParenLoc) {
1369 return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc,
1370 Cond, RParenLoc);
1371 }
1372
1373 /// Build a new for statement.
1374 ///
1375 /// By default, performs semantic analysis to build the new statement.
1376 /// Subclasses may override this routine to provide different behavior.
1377 StmtResult RebuildForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
1378 Stmt *Init, Sema::ConditionResult Cond,
1379 Sema::FullExprArg Inc, SourceLocation RParenLoc,
1380 Stmt *Body) {
1381 return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond,
1382 Inc, RParenLoc, Body);
1383 }
1384
1385 /// Build a new goto statement.
1386 ///
1387 /// By default, performs semantic analysis to build the new statement.
1388 /// Subclasses may override this routine to provide different behavior.
1389 StmtResult RebuildGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc,
1390 LabelDecl *Label) {
1391 return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label);
1392 }
1393
1394 /// Build a new indirect goto statement.
1395 ///
1396 /// By default, performs semantic analysis to build the new statement.
1397 /// Subclasses may override this routine to provide different behavior.
1398 StmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc,
1399 SourceLocation StarLoc,
1400 Expr *Target) {
1401 return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target);
1402 }
1403
1404 /// Build a new return statement.
1405 ///
1406 /// By default, performs semantic analysis to build the new statement.
1407 /// Subclasses may override this routine to provide different behavior.
1408 StmtResult RebuildReturnStmt(SourceLocation ReturnLoc, Expr *Result) {
1409 return getSema().BuildReturnStmt(ReturnLoc, Result);
1410 }
1411
1412 /// Build a new declaration statement.
1413 ///
1414 /// By default, performs semantic analysis to build the new statement.
1415 /// Subclasses may override this routine to provide different behavior.
1416 StmtResult RebuildDeclStmt(MutableArrayRef<Decl *> Decls,
1417 SourceLocation StartLoc, SourceLocation EndLoc) {
1418 Sema::DeclGroupPtrTy DG = getSema().BuildDeclaratorGroup(Decls);
1419 return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc);
1420 }
1421
1422 /// Build a new inline asm statement.
1423 ///
1424 /// By default, performs semantic analysis to build the new statement.
1425 /// Subclasses may override this routine to provide different behavior.
1426 StmtResult RebuildGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
1427 bool IsVolatile, unsigned NumOutputs,
1428 unsigned NumInputs, IdentifierInfo **Names,
1429 MultiExprArg Constraints, MultiExprArg Exprs,
1430 Expr *AsmString, MultiExprArg Clobbers,
1431 unsigned NumLabels,
1432 SourceLocation RParenLoc) {
1433 return getSema().ActOnGCCAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
1434 NumInputs, Names, Constraints, Exprs,
1435 AsmString, Clobbers, NumLabels, RParenLoc);
1436 }
1437
1438 /// Build a new MS style inline asm statement.
1439 ///
1440 /// By default, performs semantic analysis to build the new statement.
1441 /// Subclasses may override this routine to provide different behavior.
1442 StmtResult RebuildMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
1443 ArrayRef<Token> AsmToks,
1444 StringRef AsmString,
1445 unsigned NumOutputs, unsigned NumInputs,
1446 ArrayRef<StringRef> Constraints,
1447 ArrayRef<StringRef> Clobbers,
1448 ArrayRef<Expr*> Exprs,
1449 SourceLocation EndLoc) {
1450 return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, AsmString,
1451 NumOutputs, NumInputs,
1452 Constraints, Clobbers, Exprs, EndLoc);
1453 }
1454
1455 /// Build a new co_return statement.
1456 ///
1457 /// By default, performs semantic analysis to build the new statement.
1458 /// Subclasses may override this routine to provide different behavior.
1459 StmtResult RebuildCoreturnStmt(SourceLocation CoreturnLoc, Expr *Result,
1460 bool IsImplicit) {
1461 return getSema().BuildCoreturnStmt(CoreturnLoc, Result, IsImplicit);
1462 }
1463
1464 /// Build a new co_await expression.
1465 ///
1466 /// By default, performs semantic analysis to build the new expression.
1467 /// Subclasses may override this routine to provide different behavior.
1468 ExprResult RebuildCoawaitExpr(SourceLocation CoawaitLoc, Expr *Result,
1469 bool IsImplicit) {
1470 return getSema().BuildResolvedCoawaitExpr(CoawaitLoc, Result, IsImplicit);
1471 }
1472
1473 /// Build a new co_await expression.
1474 ///
1475 /// By default, performs semantic analysis to build the new expression.
1476 /// Subclasses may override this routine to provide different behavior.
1477 ExprResult RebuildDependentCoawaitExpr(SourceLocation CoawaitLoc,
1478 Expr *Result,
1479 UnresolvedLookupExpr *Lookup) {
1480 return getSema().BuildUnresolvedCoawaitExpr(CoawaitLoc, Result, Lookup);
1481 }
1482
1483 /// Build a new co_yield expression.
1484 ///
1485 /// By default, performs semantic analysis to build the new expression.
1486 /// Subclasses may override this routine to provide different behavior.
1487 ExprResult RebuildCoyieldExpr(SourceLocation CoyieldLoc, Expr *Result) {
1488 return getSema().BuildCoyieldExpr(CoyieldLoc, Result);
1489 }
1490
1491 StmtResult RebuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs Args) {
1492 return getSema().BuildCoroutineBodyStmt(Args);
1493 }
1494
1495 /// Build a new Objective-C \@try statement.
1496 ///
1497 /// By default, performs semantic analysis to build the new statement.
1498 /// Subclasses may override this routine to provide different behavior.
1499 StmtResult RebuildObjCAtTryStmt(SourceLocation AtLoc,
1500 Stmt *TryBody,
1501 MultiStmtArg CatchStmts,
1502 Stmt *Finally) {
1503 return getSema().ActOnObjCAtTryStmt(AtLoc, TryBody, CatchStmts,
1504 Finally);
1505 }
1506
1507 /// Rebuild an Objective-C exception declaration.
1508 ///
1509 /// By default, performs semantic analysis to build the new declaration.
1510 /// Subclasses may override this routine to provide different behavior.
1511 VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
1512 TypeSourceInfo *TInfo, QualType T) {
1513 return getSema().BuildObjCExceptionDecl(TInfo, T,
1514 ExceptionDecl->getInnerLocStart(),
1515 ExceptionDecl->getLocation(),
1516 ExceptionDecl->getIdentifier());
1517 }
1518
1519 /// Build a new Objective-C \@catch statement.
1520 ///
1521 /// By default, performs semantic analysis to build the new statement.
1522 /// Subclasses may override this routine to provide different behavior.
1523 StmtResult RebuildObjCAtCatchStmt(SourceLocation AtLoc,
1524 SourceLocation RParenLoc,
1525 VarDecl *Var,
1526 Stmt *Body) {
1527 return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc,
1528 Var, Body);
1529 }
1530
1531 /// Build a new Objective-C \@finally statement.
1532 ///
1533 /// By default, performs semantic analysis to build the new statement.
1534 /// Subclasses may override this routine to provide different behavior.
1535 StmtResult RebuildObjCAtFinallyStmt(SourceLocation AtLoc,
1536 Stmt *Body) {
1537 return getSema().ActOnObjCAtFinallyStmt(AtLoc, Body);
1538 }
1539
1540 /// Build a new Objective-C \@throw statement.
1541 ///
1542 /// By default, performs semantic analysis to build the new statement.
1543 /// Subclasses may override this routine to provide different behavior.
1544 StmtResult RebuildObjCAtThrowStmt(SourceLocation AtLoc,
1545 Expr *Operand) {
1546 return getSema().BuildObjCAtThrowStmt(AtLoc, Operand);
1547 }
1548
1549 /// Build a new OpenMP executable directive.
1550 ///
1551 /// By default, performs semantic analysis to build the new statement.
1552 /// Subclasses may override this routine to provide different behavior.
1553 StmtResult RebuildOMPExecutableDirective(OpenMPDirectiveKind Kind,
1554 DeclarationNameInfo DirName,
1555 OpenMPDirectiveKind CancelRegion,
1556 ArrayRef<OMPClause *> Clauses,
1557 Stmt *AStmt, SourceLocation StartLoc,
1558 SourceLocation EndLoc) {
1559 return getSema().ActOnOpenMPExecutableDirective(
1560 Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);
1561 }
1562
1563 /// Build a new OpenMP 'if' clause.
1564 ///
1565 /// By default, performs semantic analysis to build the new OpenMP clause.
1566 /// Subclasses may override this routine to provide different behavior.
1567 OMPClause *RebuildOMPIfClause(OpenMPDirectiveKind NameModifier,
1568 Expr *Condition, SourceLocation StartLoc,
1569 SourceLocation LParenLoc,
1570 SourceLocation NameModifierLoc,
1571 SourceLocation ColonLoc,
1572 SourceLocation EndLoc) {
1573 return getSema().ActOnOpenMPIfClause(NameModifier, Condition, StartLoc,
1574 LParenLoc, NameModifierLoc, ColonLoc,
1575 EndLoc);
1576 }
1577
1578 /// Build a new OpenMP 'final' clause.
1579 ///
1580 /// By default, performs semantic analysis to build the new OpenMP clause.
1581 /// Subclasses may override this routine to provide different behavior.
1582 OMPClause *RebuildOMPFinalClause(Expr *Condition, SourceLocation StartLoc,
1583 SourceLocation LParenLoc,
1584 SourceLocation EndLoc) {
1585 return getSema().ActOnOpenMPFinalClause(Condition, StartLoc, LParenLoc,
1586 EndLoc);
1587 }
1588
1589 /// Build a new OpenMP 'num_threads' clause.
1590 ///
1591 /// By default, performs semantic analysis to build the new OpenMP clause.
1592 /// Subclasses may override this routine to provide different behavior.
1593 OMPClause *RebuildOMPNumThreadsClause(Expr *NumThreads,
1594 SourceLocation StartLoc,
1595 SourceLocation LParenLoc,
1596 SourceLocation EndLoc) {
1597 return getSema().ActOnOpenMPNumThreadsClause(NumThreads, StartLoc,
1598 LParenLoc, EndLoc);
1599 }
1600
1601 /// Build a new OpenMP 'safelen' clause.
1602 ///
1603 /// By default, performs semantic analysis to build the new OpenMP clause.
1604 /// Subclasses may override this routine to provide different behavior.
1605 OMPClause *RebuildOMPSafelenClause(Expr *Len, SourceLocation StartLoc,
1606 SourceLocation LParenLoc,
1607 SourceLocation EndLoc) {
1608 return getSema().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc, EndLoc);
1609 }
1610
1611 /// Build a new OpenMP 'simdlen' clause.
1612 ///
1613 /// By default, performs semantic analysis to build the new OpenMP clause.
1614 /// Subclasses may override this routine to provide different behavior.
1615 OMPClause *RebuildOMPSimdlenClause(Expr *Len, SourceLocation StartLoc,
1616 SourceLocation LParenLoc,
1617 SourceLocation EndLoc) {
1618 return getSema().ActOnOpenMPSimdlenClause(Len, StartLoc, LParenLoc, EndLoc);
1619 }
1620
1621 /// Build a new OpenMP 'allocator' clause.
1622 ///
1623 /// By default, performs semantic analysis to build the new OpenMP clause.
1624 /// Subclasses may override this routine to provide different behavior.
1625 OMPClause *RebuildOMPAllocatorClause(Expr *A, SourceLocation StartLoc,
1626 SourceLocation LParenLoc,
1627 SourceLocation EndLoc) {
1628 return getSema().ActOnOpenMPAllocatorClause(A, StartLoc, LParenLoc, EndLoc);
1629 }
1630
1631 /// Build a new OpenMP 'collapse' clause.
1632 ///
1633 /// By default, performs semantic analysis to build the new OpenMP clause.
1634 /// Subclasses may override this routine to provide different behavior.
1635 OMPClause *RebuildOMPCollapseClause(Expr *Num, SourceLocation StartLoc,
1636 SourceLocation LParenLoc,
1637 SourceLocation EndLoc) {
1638 return getSema().ActOnOpenMPCollapseClause(Num, StartLoc, LParenLoc,
1639 EndLoc);
1640 }
1641
1642 /// Build a new OpenMP 'default' clause.
1643 ///
1644 /// By default, performs semantic analysis to build the new OpenMP clause.
1645 /// Subclasses may override this routine to provide different behavior.
1646 OMPClause *RebuildOMPDefaultClause(DefaultKind Kind, SourceLocation KindKwLoc,
1647 SourceLocation StartLoc,
1648 SourceLocation LParenLoc,
1649 SourceLocation EndLoc) {
1650 return getSema().ActOnOpenMPDefaultClause(Kind, KindKwLoc,
1651 StartLoc, LParenLoc, EndLoc);
1652 }
1653
1654 /// Build a new OpenMP 'proc_bind' clause.
1655 ///
1656 /// By default, performs semantic analysis to build the new OpenMP clause.
1657 /// Subclasses may override this routine to provide different behavior.
1658 OMPClause *RebuildOMPProcBindClause(ProcBindKind Kind,
1659 SourceLocation KindKwLoc,
1660 SourceLocation StartLoc,
1661 SourceLocation LParenLoc,
1662 SourceLocation EndLoc) {
1663 return getSema().ActOnOpenMPProcBindClause(Kind, KindKwLoc,
1664 StartLoc, LParenLoc, EndLoc);
1665 }
1666
1667 /// Build a new OpenMP 'schedule' clause.
1668 ///
1669 /// By default, performs semantic analysis to build the new OpenMP clause.
1670 /// Subclasses may override this routine to provide different behavior.
1671 OMPClause *RebuildOMPScheduleClause(
1672 OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
1673 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
1674 SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
1675 SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc) {
1676 return getSema().ActOnOpenMPScheduleClause(
1677 M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,
1678 CommaLoc, EndLoc);
1679 }
1680
1681 /// Build a new OpenMP 'ordered' clause.
1682 ///
1683 /// By default, performs semantic analysis to build the new OpenMP clause.
1684 /// Subclasses may override this routine to provide different behavior.
1685 OMPClause *RebuildOMPOrderedClause(SourceLocation StartLoc,
1686 SourceLocation EndLoc,
1687 SourceLocation LParenLoc, Expr *Num) {
1688 return getSema().ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Num);
1689 }
1690
1691 /// Build a new OpenMP 'private' clause.
1692 ///
1693 /// By default, performs semantic analysis to build the new OpenMP clause.
1694 /// Subclasses may override this routine to provide different behavior.
1695 OMPClause *RebuildOMPPrivateClause(ArrayRef<Expr *> VarList,
1696 SourceLocation StartLoc,
1697 SourceLocation LParenLoc,
1698 SourceLocation EndLoc) {
1699 return getSema().ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc,
1700 EndLoc);
1701 }
1702
1703 /// Build a new OpenMP 'firstprivate' clause.
1704 ///
1705 /// By default, performs semantic analysis to build the new OpenMP clause.
1706 /// Subclasses may override this routine to provide different behavior.
1707 OMPClause *RebuildOMPFirstprivateClause(ArrayRef<Expr *> VarList,
1708 SourceLocation StartLoc,
1709 SourceLocation LParenLoc,
1710 SourceLocation EndLoc) {
1711 return getSema().ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc,
1712 EndLoc);
1713 }
1714
1715 /// Build a new OpenMP 'lastprivate' clause.
1716 ///
1717 /// By default, performs semantic analysis to build the new OpenMP clause.
1718 /// Subclasses may override this routine to provide different behavior.
1719 OMPClause *RebuildOMPLastprivateClause(ArrayRef<Expr *> VarList,
1720 OpenMPLastprivateModifier LPKind,
1721 SourceLocation LPKindLoc,
1722 SourceLocation ColonLoc,
1723 SourceLocation StartLoc,
1724 SourceLocation LParenLoc,
1725 SourceLocation EndLoc) {
1726 return getSema().ActOnOpenMPLastprivateClause(
1727 VarList, LPKind, LPKindLoc, ColonLoc, StartLoc, LParenLoc, EndLoc);
1728 }
1729
1730 /// Build a new OpenMP 'shared' clause.
1731 ///
1732 /// By default, performs semantic analysis to build the new OpenMP clause.
1733 /// Subclasses may override this routine to provide different behavior.
1734 OMPClause *RebuildOMPSharedClause(ArrayRef<Expr *> VarList,
1735 SourceLocation StartLoc,
1736 SourceLocation LParenLoc,
1737 SourceLocation EndLoc) {
1738 return getSema().ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc,
1739 EndLoc);
1740 }
1741
1742 /// Build a new OpenMP 'reduction' clause.
1743 ///
1744 /// By default, performs semantic analysis to build the new statement.
1745 /// Subclasses may override this routine to provide different behavior.
1746 OMPClause *RebuildOMPReductionClause(
1747 ArrayRef<Expr *> VarList, OpenMPReductionClauseModifier Modifier,
1748 SourceLocation StartLoc, SourceLocation LParenLoc,
1749 SourceLocation ModifierLoc, SourceLocation ColonLoc,
1750 SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec,
1751 const DeclarationNameInfo &ReductionId,
1752 ArrayRef<Expr *> UnresolvedReductions) {
1753 return getSema().ActOnOpenMPReductionClause(
1754 VarList, Modifier, StartLoc, LParenLoc, ModifierLoc, ColonLoc, EndLoc,
1755 ReductionIdScopeSpec, ReductionId, UnresolvedReductions);
1756 }
1757
1758 /// Build a new OpenMP 'task_reduction' clause.
1759 ///
1760 /// By default, performs semantic analysis to build the new statement.
1761 /// Subclasses may override this routine to provide different behavior.
1762 OMPClause *RebuildOMPTaskReductionClause(
1763 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
1764 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
1765 CXXScopeSpec &ReductionIdScopeSpec,
1766 const DeclarationNameInfo &ReductionId,
1767 ArrayRef<Expr *> UnresolvedReductions) {
1768 return getSema().ActOnOpenMPTaskReductionClause(
1769 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1770 ReductionId, UnresolvedReductions);
1771 }
1772
1773 /// Build a new OpenMP 'in_reduction' clause.
1774 ///
1775 /// By default, performs semantic analysis to build the new statement.
1776 /// Subclasses may override this routine to provide different behavior.
1777 OMPClause *
1778 RebuildOMPInReductionClause(ArrayRef<Expr *> VarList, SourceLocation StartLoc,
1779 SourceLocation LParenLoc, SourceLocation ColonLoc,
1780 SourceLocation EndLoc,
1781 CXXScopeSpec &ReductionIdScopeSpec,
1782 const DeclarationNameInfo &ReductionId,
1783 ArrayRef<Expr *> UnresolvedReductions) {
1784 return getSema().ActOnOpenMPInReductionClause(
1785 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1786 ReductionId, UnresolvedReductions);
1787 }
1788
1789 /// Build a new OpenMP 'linear' clause.
1790 ///
1791 /// By default, performs semantic analysis to build the new OpenMP clause.
1792 /// Subclasses may override this routine to provide different behavior.
1793 OMPClause *RebuildOMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step,
1794 SourceLocation StartLoc,
1795 SourceLocation LParenLoc,
1796 OpenMPLinearClauseKind Modifier,
1797 SourceLocation ModifierLoc,
1798 SourceLocation ColonLoc,
1799 SourceLocation EndLoc) {
1800 return getSema().ActOnOpenMPLinearClause(VarList, Step, StartLoc, LParenLoc,
1801 Modifier, ModifierLoc, ColonLoc,
1802 EndLoc);
1803 }
1804
1805 /// Build a new OpenMP 'aligned' clause.
1806 ///
1807 /// By default, performs semantic analysis to build the new OpenMP clause.
1808 /// Subclasses may override this routine to provide different behavior.
1809 OMPClause *RebuildOMPAlignedClause(ArrayRef<Expr *> VarList, Expr *Alignment,
1810 SourceLocation StartLoc,
1811 SourceLocation LParenLoc,
1812 SourceLocation ColonLoc,
1813 SourceLocation EndLoc) {
1814 return getSema().ActOnOpenMPAlignedClause(VarList, Alignment, StartLoc,
1815 LParenLoc, ColonLoc, EndLoc);
1816 }
1817
1818 /// Build a new OpenMP 'copyin' clause.
1819 ///
1820 /// By default, performs semantic analysis to build the new OpenMP clause.
1821 /// Subclasses may override this routine to provide different behavior.
1822 OMPClause *RebuildOMPCopyinClause(ArrayRef<Expr *> VarList,
1823 SourceLocation StartLoc,
1824 SourceLocation LParenLoc,
1825 SourceLocation EndLoc) {
1826 return getSema().ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc,
1827 EndLoc);
1828 }
1829
1830 /// Build a new OpenMP 'copyprivate' clause.
1831 ///
1832 /// By default, performs semantic analysis to build the new OpenMP clause.
1833 /// Subclasses may override this routine to provide different behavior.
1834 OMPClause *RebuildOMPCopyprivateClause(ArrayRef<Expr *> VarList,
1835 SourceLocation StartLoc,
1836 SourceLocation LParenLoc,
1837 SourceLocation EndLoc) {
1838 return getSema().ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc,
1839 EndLoc);
1840 }
1841
1842 /// Build a new OpenMP 'flush' pseudo clause.
1843 ///
1844 /// By default, performs semantic analysis to build the new OpenMP clause.
1845 /// Subclasses may override this routine to provide different behavior.
1846 OMPClause *RebuildOMPFlushClause(ArrayRef<Expr *> VarList,
1847 SourceLocation StartLoc,
1848 SourceLocation LParenLoc,
1849 SourceLocation EndLoc) {
1850 return getSema().ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc,
1851 EndLoc);
1852 }
1853
1854 /// Build a new OpenMP 'depobj' pseudo clause.
1855 ///
1856 /// By default, performs semantic analysis to build the new OpenMP clause.
1857 /// Subclasses may override this routine to provide different behavior.
1858 OMPClause *RebuildOMPDepobjClause(Expr *Depobj, SourceLocation StartLoc,
1859 SourceLocation LParenLoc,
1860 SourceLocation EndLoc) {
1861 return getSema().ActOnOpenMPDepobjClause(Depobj, StartLoc, LParenLoc,
1862 EndLoc);
1863 }
1864
1865 /// Build a new OpenMP 'depend' pseudo clause.
1866 ///
1867 /// By default, performs semantic analysis to build the new OpenMP clause.
1868 /// Subclasses may override this routine to provide different behavior.
1869 OMPClause *
1870 RebuildOMPDependClause(Expr *DepModifier, OpenMPDependClauseKind DepKind,
1871 SourceLocation DepLoc, SourceLocation ColonLoc,
1872 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
1873 SourceLocation LParenLoc, SourceLocation EndLoc) {
1874 return getSema().ActOnOpenMPDependClause(DepModifier, DepKind, DepLoc,
1875 ColonLoc, VarList, StartLoc,
1876 LParenLoc, EndLoc);
1877 }
1878
1879 /// Build a new OpenMP 'device' clause.
1880 ///
1881 /// By default, performs semantic analysis to build the new statement.
1882 /// Subclasses may override this routine to provide different behavior.
1883 OMPClause *RebuildOMPDeviceClause(OpenMPDeviceClauseModifier Modifier,
1884 Expr *Device, SourceLocation StartLoc,
1885 SourceLocation LParenLoc,
1886 SourceLocation ModifierLoc,
1887 SourceLocation EndLoc) {
1888 return getSema().ActOnOpenMPDeviceClause(Modifier, Device, StartLoc,
1889 LParenLoc, ModifierLoc, EndLoc);
1890 }
1891
1892 /// Build a new OpenMP 'map' clause.
1893 ///
1894 /// By default, performs semantic analysis to build the new OpenMP clause.
1895 /// Subclasses may override this routine to provide different behavior.
1896 OMPClause *RebuildOMPMapClause(
1897 ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,
1898 ArrayRef<SourceLocation> MapTypeModifiersLoc,
1899 CXXScopeSpec MapperIdScopeSpec, DeclarationNameInfo MapperId,
1900 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
1901 SourceLocation MapLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
1902 const OMPVarListLocTy &Locs, ArrayRef<Expr *> UnresolvedMappers) {
1903 return getSema().ActOnOpenMPMapClause(MapTypeModifiers, MapTypeModifiersLoc,
1904 MapperIdScopeSpec, MapperId, MapType,
1905 IsMapTypeImplicit, MapLoc, ColonLoc,
1906 VarList, Locs, UnresolvedMappers);
1907 }
1908
1909 /// Build a new OpenMP 'allocate' clause.
1910 ///
1911 /// By default, performs semantic analysis to build the new OpenMP clause.
1912 /// Subclasses may override this routine to provide different behavior.
1913 OMPClause *RebuildOMPAllocateClause(Expr *Allocate, ArrayRef<Expr *> VarList,
1914 SourceLocation StartLoc,
1915 SourceLocation LParenLoc,
1916 SourceLocation ColonLoc,
1917 SourceLocation EndLoc) {
1918 return getSema().ActOnOpenMPAllocateClause(Allocate, VarList, StartLoc,
1919 LParenLoc, ColonLoc, EndLoc);
1920 }
1921
1922 /// Build a new OpenMP 'num_teams' clause.
1923 ///
1924 /// By default, performs semantic analysis to build the new statement.
1925 /// Subclasses may override this routine to provide different behavior.
1926 OMPClause *RebuildOMPNumTeamsClause(Expr *NumTeams, SourceLocation StartLoc,
1927 SourceLocation LParenLoc,
1928 SourceLocation EndLoc) {
1929 return getSema().ActOnOpenMPNumTeamsClause(NumTeams, StartLoc, LParenLoc,
1930 EndLoc);
1931 }
1932
1933 /// Build a new OpenMP 'thread_limit' clause.
1934 ///
1935 /// By default, performs semantic analysis to build the new statement.
1936 /// Subclasses may override this routine to provide different behavior.
1937 OMPClause *RebuildOMPThreadLimitClause(Expr *ThreadLimit,
1938 SourceLocation StartLoc,
1939 SourceLocation LParenLoc,
1940 SourceLocation EndLoc) {
1941 return getSema().ActOnOpenMPThreadLimitClause(ThreadLimit, StartLoc,
1942 LParenLoc, EndLoc);
1943 }
1944
1945 /// Build a new OpenMP 'priority' clause.
1946 ///
1947 /// By default, performs semantic analysis to build the new statement.
1948 /// Subclasses may override this routine to provide different behavior.
1949 OMPClause *RebuildOMPPriorityClause(Expr *Priority, SourceLocation StartLoc,
1950 SourceLocation LParenLoc,
1951 SourceLocation EndLoc) {
1952 return getSema().ActOnOpenMPPriorityClause(Priority, StartLoc, LParenLoc,
1953 EndLoc);
1954 }
1955
1956 /// Build a new OpenMP 'grainsize' clause.
1957 ///
1958 /// By default, performs semantic analysis to build the new statement.
1959 /// Subclasses may override this routine to provide different behavior.
1960 OMPClause *RebuildOMPGrainsizeClause(Expr *Grainsize, SourceLocation StartLoc,
1961 SourceLocation LParenLoc,
1962 SourceLocation EndLoc) {
1963 return getSema().ActOnOpenMPGrainsizeClause(Grainsize, StartLoc, LParenLoc,
1964 EndLoc);
1965 }
1966
1967 /// Build a new OpenMP 'num_tasks' clause.
1968 ///
1969 /// By default, performs semantic analysis to build the new statement.
1970 /// Subclasses may override this routine to provide different behavior.
1971 OMPClause *RebuildOMPNumTasksClause(Expr *NumTasks, SourceLocation StartLoc,
1972 SourceLocation LParenLoc,
1973 SourceLocation EndLoc) {
1974 return getSema().ActOnOpenMPNumTasksClause(NumTasks, StartLoc, LParenLoc,
1975 EndLoc);
1976 }
1977
1978 /// Build a new OpenMP 'hint' clause.
1979 ///
1980 /// By default, performs semantic analysis to build the new statement.
1981 /// Subclasses may override this routine to provide different behavior.
1982 OMPClause *RebuildOMPHintClause(Expr *Hint, SourceLocation StartLoc,
1983 SourceLocation LParenLoc,
1984 SourceLocation EndLoc) {
1985 return getSema().ActOnOpenMPHintClause(Hint, StartLoc, LParenLoc, EndLoc);
1986 }
1987
1988 /// Build a new OpenMP 'detach' clause.
1989 ///
1990 /// By default, performs semantic analysis to build the new statement.
1991 /// Subclasses may override this routine to provide different behavior.
1992 OMPClause *RebuildOMPDetachClause(Expr *Evt, SourceLocation StartLoc,
1993 SourceLocation LParenLoc,
1994 SourceLocation EndLoc) {
1995 return getSema().ActOnOpenMPDetachClause(Evt, StartLoc, LParenLoc, EndLoc);
1996 }
1997
1998 /// Build a new OpenMP 'dist_schedule' clause.
1999 ///
2000 /// By default, performs semantic analysis to build the new OpenMP clause.
2001 /// Subclasses may override this routine to provide different behavior.
2002 OMPClause *
2003 RebuildOMPDistScheduleClause(OpenMPDistScheduleClauseKind Kind,
2004 Expr *ChunkSize, SourceLocation StartLoc,
2005 SourceLocation LParenLoc, SourceLocation KindLoc,
2006 SourceLocation CommaLoc, SourceLocation EndLoc) {
2007 return getSema().ActOnOpenMPDistScheduleClause(
2008 Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc);
2009 }
2010
2011 /// Build a new OpenMP 'to' clause.
2012 ///
2013 /// By default, performs semantic analysis to build the new statement.
2014 /// Subclasses may override this routine to provide different behavior.
2015 OMPClause *
2016 RebuildOMPToClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
2017 ArrayRef<SourceLocation> MotionModifiersLoc,
2018 CXXScopeSpec &MapperIdScopeSpec,
2019 DeclarationNameInfo &MapperId, SourceLocation ColonLoc,
2020 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
2021 ArrayRef<Expr *> UnresolvedMappers) {
2022 return getSema().ActOnOpenMPToClause(MotionModifiers, MotionModifiersLoc,
2023 MapperIdScopeSpec, MapperId, ColonLoc,
2024 VarList, Locs, UnresolvedMappers);
2025 }
2026
2027 /// Build a new OpenMP 'from' clause.
2028 ///
2029 /// By default, performs semantic analysis to build the new statement.
2030 /// Subclasses may override this routine to provide different behavior.
2031 OMPClause *
2032 RebuildOMPFromClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
2033 ArrayRef<SourceLocation> MotionModifiersLoc,
2034 CXXScopeSpec &MapperIdScopeSpec,
2035 DeclarationNameInfo &MapperId, SourceLocation ColonLoc,
2036 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
2037 ArrayRef<Expr *> UnresolvedMappers) {
2038 return getSema().ActOnOpenMPFromClause(
2039 MotionModifiers, MotionModifiersLoc, MapperIdScopeSpec, MapperId,
2040 ColonLoc, VarList, Locs, UnresolvedMappers);
2041 }
2042
2043 /// Build a new OpenMP 'use_device_ptr' clause.
2044 ///
2045 /// By default, performs semantic analysis to build the new OpenMP clause.
2046 /// Subclasses may override this routine to provide different behavior.
2047 OMPClause *RebuildOMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
2048 const OMPVarListLocTy &Locs) {
2049 return getSema().ActOnOpenMPUseDevicePtrClause(VarList, Locs);
2050 }
2051
2052 /// Build a new OpenMP 'use_device_addr' clause.
2053 ///
2054 /// By default, performs semantic analysis to build the new OpenMP clause.
2055 /// Subclasses may override this routine to provide different behavior.
2056 OMPClause *RebuildOMPUseDeviceAddrClause(ArrayRef<Expr *> VarList,
2057 const OMPVarListLocTy &Locs) {
2058 return getSema().ActOnOpenMPUseDeviceAddrClause(VarList, Locs);
2059 }
2060
2061 /// Build a new OpenMP 'is_device_ptr' clause.
2062 ///
2063 /// By default, performs semantic analysis to build the new OpenMP clause.
2064 /// Subclasses may override this routine to provide different behavior.
2065 OMPClause *RebuildOMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
2066 const OMPVarListLocTy &Locs) {
2067 return getSema().ActOnOpenMPIsDevicePtrClause(VarList, Locs);
2068 }
2069
2070 /// Build a new OpenMP 'defaultmap' clause.
2071 ///
2072 /// By default, performs semantic analysis to build the new OpenMP clause.
2073 /// Subclasses may override this routine to provide different behavior.
2074 OMPClause *RebuildOMPDefaultmapClause(OpenMPDefaultmapClauseModifier M,
2075 OpenMPDefaultmapClauseKind Kind,
2076 SourceLocation StartLoc,
2077 SourceLocation LParenLoc,
2078 SourceLocation MLoc,
2079 SourceLocation KindLoc,
2080 SourceLocation EndLoc) {
2081 return getSema().ActOnOpenMPDefaultmapClause(M, Kind, StartLoc, LParenLoc,
2082 MLoc, KindLoc, EndLoc);
2083 }
2084
2085 /// Build a new OpenMP 'nontemporal' clause.
2086 ///
2087 /// By default, performs semantic analysis to build the new OpenMP clause.
2088 /// Subclasses may override this routine to provide different behavior.
2089 OMPClause *RebuildOMPNontemporalClause(ArrayRef<Expr *> VarList,
2090 SourceLocation StartLoc,
2091 SourceLocation LParenLoc,
2092 SourceLocation EndLoc) {
2093 return getSema().ActOnOpenMPNontemporalClause(VarList, StartLoc, LParenLoc,
2094 EndLoc);
2095 }
2096
2097 /// Build a new OpenMP 'inclusive' clause.
2098 ///
2099 /// By default, performs semantic analysis to build the new OpenMP clause.
2100 /// Subclasses may override this routine to provide different behavior.
2101 OMPClause *RebuildOMPInclusiveClause(ArrayRef<Expr *> VarList,
2102 SourceLocation StartLoc,
2103 SourceLocation LParenLoc,
2104 SourceLocation EndLoc) {
2105 return getSema().ActOnOpenMPInclusiveClause(VarList, StartLoc, LParenLoc,
2106 EndLoc);
2107 }
2108
2109 /// Build a new OpenMP 'exclusive' clause.
2110 ///
2111 /// By default, performs semantic analysis to build the new OpenMP clause.
2112 /// Subclasses may override this routine to provide different behavior.
2113 OMPClause *RebuildOMPExclusiveClause(ArrayRef<Expr *> VarList,
2114 SourceLocation StartLoc,
2115 SourceLocation LParenLoc,
2116 SourceLocation EndLoc) {
2117 return getSema().ActOnOpenMPExclusiveClause(VarList, StartLoc, LParenLoc,
2118 EndLoc);
2119 }
2120
2121 /// Build a new OpenMP 'uses_allocators' clause.
2122 ///
2123 /// By default, performs semantic analysis to build the new OpenMP clause.
2124 /// Subclasses may override this routine to provide different behavior.
2125 OMPClause *RebuildOMPUsesAllocatorsClause(
2126 ArrayRef<Sema::UsesAllocatorsData> Data, SourceLocation StartLoc,
2127 SourceLocation LParenLoc, SourceLocation EndLoc) {
2128 return getSema().ActOnOpenMPUsesAllocatorClause(StartLoc, LParenLoc, EndLoc,
2129 Data);
2130 }
2131
2132 /// Build a new OpenMP 'affinity' clause.
2133 ///
2134 /// By default, performs semantic analysis to build the new OpenMP clause.
2135 /// Subclasses may override this routine to provide different behavior.
2136 OMPClause *RebuildOMPAffinityClause(SourceLocation StartLoc,
2137 SourceLocation LParenLoc,
2138 SourceLocation ColonLoc,
2139 SourceLocation EndLoc, Expr *Modifier,
2140 ArrayRef<Expr *> Locators) {
2141 return getSema().ActOnOpenMPAffinityClause(StartLoc, LParenLoc, ColonLoc,
2142 EndLoc, Modifier, Locators);
2143 }
2144
2145 /// Build a new OpenMP 'order' clause.
2146 ///
2147 /// By default, performs semantic analysis to build the new OpenMP clause.
2148 /// Subclasses may override this routine to provide different behavior.
2149 OMPClause *RebuildOMPOrderClause(OpenMPOrderClauseKind Kind,
2150 SourceLocation KindKwLoc,
2151 SourceLocation StartLoc,
2152 SourceLocation LParenLoc,
2153 SourceLocation EndLoc) {
2154 return getSema().ActOnOpenMPOrderClause(Kind, KindKwLoc, StartLoc,
2155 LParenLoc, EndLoc);
2156 }
2157
2158 /// Rebuild the operand to an Objective-C \@synchronized statement.
2159 ///
2160 /// By default, performs semantic analysis to build the new statement.
2161 /// Subclasses may override this routine to provide different behavior.
2162 ExprResult RebuildObjCAtSynchronizedOperand(SourceLocation atLoc,
2163 Expr *object) {
2164 return getSema().ActOnObjCAtSynchronizedOperand(atLoc, object);
2165 }
2166
2167 /// Build a new Objective-C \@synchronized statement.
2168 ///
2169 /// By default, performs semantic analysis to build the new statement.
2170 /// Subclasses may override this routine to provide different behavior.
2171 StmtResult RebuildObjCAtSynchronizedStmt(SourceLocation AtLoc,
2172 Expr *Object, Stmt *Body) {
2173 return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, Object, Body);
2174 }
2175
2176 /// Build a new Objective-C \@autoreleasepool statement.
2177 ///
2178 /// By default, performs semantic analysis to build the new statement.
2179 /// Subclasses may override this routine to provide different behavior.
2180 StmtResult RebuildObjCAutoreleasePoolStmt(SourceLocation AtLoc,
2181 Stmt *Body) {
2182 return getSema().ActOnObjCAutoreleasePoolStmt(AtLoc, Body);
2183 }
2184
2185 /// Build a new Objective-C fast enumeration statement.
2186 ///
2187 /// By default, performs semantic analysis to build the new statement.
2188 /// Subclasses may override this routine to provide different behavior.
2189 StmtResult RebuildObjCForCollectionStmt(SourceLocation ForLoc,
2190 Stmt *Element,
2191 Expr *Collection,
2192 SourceLocation RParenLoc,
2193 Stmt *Body) {
2194 StmtResult ForEachStmt = getSema().ActOnObjCForCollectionStmt(ForLoc,
2195 Element,
2196 Collection,
2197 RParenLoc);
2198 if (ForEachStmt.isInvalid())
2199 return StmtError();
2200
2201 return getSema().FinishObjCForCollectionStmt(ForEachStmt.get(), Body);
2202 }
2203
2204 /// Build a new C++ exception declaration.
2205 ///
2206 /// By default, performs semantic analysis to build the new decaration.
2207 /// Subclasses may override this routine to provide different behavior.
2208 VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl,
2209 TypeSourceInfo *Declarator,
2210 SourceLocation StartLoc,
2211 SourceLocation IdLoc,
2212 IdentifierInfo *Id) {
2213 VarDecl *Var = getSema().BuildExceptionDeclaration(nullptr, Declarator,
2214 StartLoc, IdLoc, Id);
2215 if (Var)
2216 getSema().CurContext->addDecl(Var);
2217 return Var;
2218 }
2219
2220 /// Build a new C++ catch statement.
2221 ///
2222 /// By default, performs semantic analysis to build the new statement.
2223 /// Subclasses may override this routine to provide different behavior.
2224 StmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc,
2225 VarDecl *ExceptionDecl,
2226 Stmt *Handler) {
2227 return Owned(new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl,
2228 Handler));
2229 }
2230
2231 /// Build a new C++ try statement.
2232 ///
2233 /// By default, performs semantic analysis to build the new statement.
2234 /// Subclasses may override this routine to provide different behavior.
2235 StmtResult RebuildCXXTryStmt(SourceLocation TryLoc, Stmt *TryBlock,
2236 ArrayRef<Stmt *> Handlers) {
2237 return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, Handlers);
2238 }
2239
2240 /// Build a new C++0x range-based for statement.
2241 ///
2242 /// By default, performs semantic analysis to build the new statement.
2243 /// Subclasses may override this routine to provide different behavior.
2244 StmtResult RebuildCXXForRangeStmt(SourceLocation ForLoc,
2245 SourceLocation CoawaitLoc, Stmt *Init,
2246 SourceLocation ColonLoc, Stmt *Range,
2247 Stmt *Begin, Stmt *End, Expr *Cond,
2248 Expr *Inc, Stmt *LoopVar,
2249 SourceLocation RParenLoc) {
2250 // If we've just learned that the range is actually an Objective-C
2251 // collection, treat this as an Objective-C fast enumeration loop.
2252 if (DeclStmt *RangeStmt = dyn_cast<DeclStmt>(Range)) {
2253 if (RangeStmt->isSingleDecl()) {
2254 if (VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {
2255 if (RangeVar->isInvalidDecl())
2256 return StmtError();
2257
2258 Expr *RangeExpr = RangeVar->getInit();
2259 if (!RangeExpr->isTypeDependent() &&
2260 RangeExpr->getType()->isObjCObjectPointerType()) {
2261 // FIXME: Support init-statements in Objective-C++20 ranged for
2262 // statement.
2263 if (Init) {
2264 return SemaRef.Diag(Init->getBeginLoc(),
2265 diag::err_objc_for_range_init_stmt)
2266 << Init->getSourceRange();
2267 }
2268 return getSema().ActOnObjCForCollectionStmt(ForLoc, LoopVar,
2269 RangeExpr, RParenLoc);
2270 }
2271 }
2272 }
2273 }
2274
2275 return getSema().BuildCXXForRangeStmt(ForLoc, CoawaitLoc, Init, ColonLoc,
2276 Range, Begin, End, Cond, Inc, LoopVar,
2277 RParenLoc, Sema::BFRK_Rebuild);
2278 }
2279
2280 /// Build a new C++0x range-based for statement.
2281 ///
2282 /// By default, performs semantic analysis to build the new statement.
2283 /// Subclasses may override this routine to provide different behavior.
2284 StmtResult RebuildMSDependentExistsStmt(SourceLocation KeywordLoc,
2285 bool IsIfExists,
2286 NestedNameSpecifierLoc QualifierLoc,
2287 DeclarationNameInfo NameInfo,
2288 Stmt *Nested) {
2289 return getSema().BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
2290 QualifierLoc, NameInfo, Nested);
2291 }
2292
2293 /// Attach body to a C++0x range-based for statement.
2294 ///
2295 /// By default, performs semantic analysis to finish the new statement.
2296 /// Subclasses may override this routine to provide different behavior.
2297 StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body) {
2298 return getSema().FinishCXXForRangeStmt(ForRange, Body);
2299 }
2300
2301 StmtResult RebuildSEHTryStmt(bool IsCXXTry, SourceLocation TryLoc,
2302 Stmt *TryBlock, Stmt *Handler) {
2303 return getSema().ActOnSEHTryBlock(IsCXXTry, TryLoc, TryBlock, Handler);
2304 }
2305
2306 StmtResult RebuildSEHExceptStmt(SourceLocation Loc, Expr *FilterExpr,
2307 Stmt *Block) {
2308 return getSema().ActOnSEHExceptBlock(Loc, FilterExpr, Block);
2309 }
2310
2311 StmtResult RebuildSEHFinallyStmt(SourceLocation Loc, Stmt *Block) {
2312 return SEHFinallyStmt::Create(getSema().getASTContext(), Loc, Block);
2313 }
2314
2315 /// Build a new predefined expression.
2316 ///
2317 /// By default, performs semantic analysis to build the new expression.
2318 /// Subclasses may override this routine to provide different behavior.
2319 ExprResult RebuildPredefinedExpr(SourceLocation Loc,
2320 PredefinedExpr::IdentKind IK) {
2321 return getSema().BuildPredefinedExpr(Loc, IK);
2322 }
2323
2324 /// Build a new expression that references a declaration.
2325 ///
2326 /// By default, performs semantic analysis to build the new expression.
2327 /// Subclasses may override this routine to provide different behavior.
2328 ExprResult RebuildDeclarationNameExpr(const CXXScopeSpec &SS,
2329 LookupResult &R,
2330 bool RequiresADL) {
2331 return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
2332 }
2333
2334
2335 /// Build a new expression that references a declaration.
2336 ///
2337 /// By default, performs semantic analysis to build the new expression.
2338 /// Subclasses may override this routine to provide different behavior.
2339 ExprResult RebuildDeclRefExpr(NestedNameSpecifierLoc QualifierLoc,
2340 ValueDecl *VD,
2341 const DeclarationNameInfo &NameInfo,
2342 NamedDecl *Found,
2343 TemplateArgumentListInfo *TemplateArgs) {
2344 CXXScopeSpec SS;
2345 SS.Adopt(QualifierLoc);
2346 return getSema().BuildDeclarationNameExpr(SS, NameInfo, VD, Found,
2347 TemplateArgs);
2348 }
2349
2350 /// Build a new expression in parentheses.
2351 ///
2352 /// By default, performs semantic analysis to build the new expression.
2353 /// Subclasses may override this routine to provide different behavior.
2354 ExprResult RebuildParenExpr(Expr *SubExpr, SourceLocation LParen,
2355 SourceLocation RParen) {
2356 return getSema().ActOnParenExpr(LParen, RParen, SubExpr);
2357 }
2358
2359 /// Build a new pseudo-destructor expression.
2360 ///
2361 /// By default, performs semantic analysis to build the new expression.
2362 /// Subclasses may override this routine to provide different behavior.
2363 ExprResult RebuildCXXPseudoDestructorExpr(Expr *Base,
2364 SourceLocation OperatorLoc,
2365 bool isArrow,
2366 CXXScopeSpec &SS,
2367 TypeSourceInfo *ScopeType,
2368 SourceLocation CCLoc,
2369 SourceLocation TildeLoc,
2370 PseudoDestructorTypeStorage Destroyed);
2371
2372 /// Build a new unary operator expression.
2373 ///
2374 /// By default, performs semantic analysis to build the new expression.
2375 /// Subclasses may override this routine to provide different behavior.
2376 ExprResult RebuildUnaryOperator(SourceLocation OpLoc,
2377 UnaryOperatorKind Opc,
2378 Expr *SubExpr) {
2379 return getSema().BuildUnaryOp(/*Scope=*/nullptr, OpLoc, Opc, SubExpr);
2380 }
2381
2382 /// Build a new builtin offsetof expression.
2383 ///
2384 /// By default, performs semantic analysis to build the new expression.
2385 /// Subclasses may override this routine to provide different behavior.
2386 ExprResult RebuildOffsetOfExpr(SourceLocation OperatorLoc,
2387 TypeSourceInfo *Type,
2388 ArrayRef<Sema::OffsetOfComponent> Components,
2389 SourceLocation RParenLoc) {
2390 return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Components,
2391 RParenLoc);
2392 }
2393
2394 /// Build a new sizeof, alignof or vec_step expression with a
2395 /// type argument.
2396 ///
2397 /// By default, performs semantic analysis to build the new expression.
2398 /// Subclasses may override this routine to provide different behavior.
2399 ExprResult RebuildUnaryExprOrTypeTrait(TypeSourceInfo *TInfo,
2400 SourceLocation OpLoc,
2401 UnaryExprOrTypeTrait ExprKind,
2402 SourceRange R) {
2403 return getSema().CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, R);
2404 }
2405
2406 /// Build a new sizeof, alignof or vec step expression with an
2407 /// expression argument.
2408 ///
2409 /// By default, performs semantic analysis to build the new expression.
2410 /// Subclasses may override this routine to provide different behavior.
2411 ExprResult RebuildUnaryExprOrTypeTrait(Expr *SubExpr, SourceLocation OpLoc,
2412 UnaryExprOrTypeTrait ExprKind,
2413 SourceRange R) {
2414 ExprResult Result
2415 = getSema().CreateUnaryExprOrTypeTraitExpr(SubExpr, OpLoc, ExprKind);
2416 if (Result.isInvalid())
2417 return ExprError();
2418
2419 return Result;
2420 }
2421
2422 /// Build a new array subscript expression.
2423 ///
2424 /// By default, performs semantic analysis to build the new expression.
2425 /// Subclasses may override this routine to provide different behavior.
2426 ExprResult RebuildArraySubscriptExpr(Expr *LHS,
2427 SourceLocation LBracketLoc,
2428 Expr *RHS,
2429 SourceLocation RBracketLoc) {
2430 return getSema().ActOnArraySubscriptExpr(/*Scope=*/nullptr, LHS,
2431 LBracketLoc, RHS,
2432 RBracketLoc);
2433 }
2434
2435 /// Build a new matrix subscript expression.
2436 ///
2437 /// By default, performs semantic analysis to build the new expression.
2438 /// Subclasses may override this routine to provide different behavior.
2439 ExprResult RebuildMatrixSubscriptExpr(Expr *Base, Expr *RowIdx,
2440 Expr *ColumnIdx,
2441 SourceLocation RBracketLoc) {
2442 return getSema().CreateBuiltinMatrixSubscriptExpr(Base, RowIdx, ColumnIdx,
2443 RBracketLoc);
2444 }
2445
2446 /// Build a new array section expression.
2447 ///
2448 /// By default, performs semantic analysis to build the new expression.
2449 /// Subclasses may override this routine to provide different behavior.
2450 ExprResult RebuildOMPArraySectionExpr(Expr *Base, SourceLocation LBracketLoc,
2451 Expr *LowerBound,
2452 SourceLocation ColonLocFirst,
2453 SourceLocation ColonLocSecond,
2454 Expr *Length, Expr *Stride,
2455 SourceLocation RBracketLoc) {
2456 return getSema().ActOnOMPArraySectionExpr(Base, LBracketLoc, LowerBound,
2457 ColonLocFirst, ColonLocSecond,
2458 Length, Stride, RBracketLoc);
2459 }
2460
2461 /// Build a new array shaping expression.
2462 ///
2463 /// By default, performs semantic analysis to build the new expression.
2464 /// Subclasses may override this routine to provide different behavior.
2465 ExprResult RebuildOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc,
2466 SourceLocation RParenLoc,
2467 ArrayRef<Expr *> Dims,
2468 ArrayRef<SourceRange> BracketsRanges) {
2469 return getSema().ActOnOMPArrayShapingExpr(Base, LParenLoc, RParenLoc, Dims,
2470 BracketsRanges);
2471 }
2472
2473 /// Build a new iterator expression.
2474 ///
2475 /// By default, performs semantic analysis to build the new expression.
2476 /// Subclasses may override this routine to provide different behavior.
2477 ExprResult RebuildOMPIteratorExpr(
2478 SourceLocation IteratorKwLoc, SourceLocation LLoc, SourceLocation RLoc,
2479 ArrayRef<Sema::OMPIteratorData> Data) {
2480 return getSema().ActOnOMPIteratorExpr(/*Scope=*/nullptr, IteratorKwLoc,
2481 LLoc, RLoc, Data);
2482 }
2483
2484 /// Build a new call expression.
2485 ///
2486 /// By default, performs semantic analysis to build the new expression.
2487 /// Subclasses may override this routine to provide different behavior.
2488 ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc,
2489 MultiExprArg Args,
2490 SourceLocation RParenLoc,
2491 Expr *ExecConfig = nullptr) {
2492 return getSema().ActOnCallExpr(
2493 /*Scope=*/nullptr, Callee, LParenLoc, Args, RParenLoc, ExecConfig);
2494 }
2495
2496 /// Build a new member access expression.
2497 ///
2498 /// By default, performs semantic analysis to build the new expression.
2499 /// Subclasses may override this routine to provide different behavior.
2500 ExprResult RebuildMemberExpr(Expr *Base, SourceLocation OpLoc,
2501 bool isArrow,
2502 NestedNameSpecifierLoc QualifierLoc,
2503 SourceLocation TemplateKWLoc,
2504 const DeclarationNameInfo &MemberNameInfo,
2505 ValueDecl *Member,
2506 NamedDecl *FoundDecl,
2507 const TemplateArgumentListInfo *ExplicitTemplateArgs,
2508 NamedDecl *FirstQualifierInScope) {
2509 ExprResult BaseResult = getSema().PerformMemberExprBaseConversion(Base,
2510 isArrow);
2511 if (!Member->getDeclName()) {
2512 // We have a reference to an unnamed field. This is always the
2513 // base of an anonymous struct/union member access, i.e. the
2514 // field is always of record type.
2515 assert(Member->getType()->isRecordType() &&
2516 "unnamed member not of record type?");
2517
2518 BaseResult =
2519 getSema().PerformObjectMemberConversion(BaseResult.get(),
2520 QualifierLoc.getNestedNameSpecifier(),
2521 FoundDecl, Member);
2522 if (BaseResult.isInvalid())
2523 return ExprError();
2524 Base = BaseResult.get();
2525
2526 CXXScopeSpec EmptySS;
2527 return getSema().BuildFieldReferenceExpr(
2528 Base, isArrow, OpLoc, EmptySS, cast<FieldDecl>(Member),
2529 DeclAccessPair::make(FoundDecl, FoundDecl->getAccess()), MemberNameInfo);
2530 }
2531
2532 CXXScopeSpec SS;
2533 SS.Adopt(QualifierLoc);
2534
2535 Base = BaseResult.get();
2536 QualType BaseType = Base->getType();
2537
2538 if (isArrow && !BaseType->isPointerType())
2539 return ExprError();
2540
2541 // FIXME: this involves duplicating earlier analysis in a lot of
2542 // cases; we should avoid this when possible.
2543 LookupResult R(getSema(), MemberNameInfo, Sema::LookupMemberName);
2544 R.addDecl(FoundDecl);
2545 R.resolveKind();
2546
2547 return getSema().BuildMemberReferenceExpr(Base, BaseType, OpLoc, isArrow,
2548 SS, TemplateKWLoc,
2549 FirstQualifierInScope,
2550 R, ExplicitTemplateArgs,
2551 /*S*/nullptr);
2552 }
2553
2554 /// Build a new binary operator expression.
2555 ///
2556 /// By default, performs semantic analysis to build the new expression.
2557 /// Subclasses may override this routine to provide different behavior.
2558 ExprResult RebuildBinaryOperator(SourceLocation OpLoc,
2559 BinaryOperatorKind Opc,
2560 Expr *LHS, Expr *RHS) {
2561 return getSema().BuildBinOp(/*Scope=*/nullptr, OpLoc, Opc, LHS, RHS);
2562 }
2563
2564 /// Build a new rewritten operator expression.
2565 ///
2566 /// By default, performs semantic analysis to build the new expression.
2567 /// Subclasses may override this routine to provide different behavior.
2568 ExprResult RebuildCXXRewrittenBinaryOperator(
2569 SourceLocation OpLoc, BinaryOperatorKind Opcode,
2570 const UnresolvedSetImpl &UnqualLookups, Expr *LHS, Expr *RHS) {
2571 return getSema().CreateOverloadedBinOp(OpLoc, Opcode, UnqualLookups, LHS,
2572 RHS, /*RequiresADL*/false);
2573 }
2574
2575 /// Build a new conditional operator expression.
2576 ///
2577 /// By default, performs semantic analysis to build the new expression.
2578 /// Subclasses may override this routine to provide different behavior.
2579 ExprResult RebuildConditionalOperator(Expr *Cond,
2580 SourceLocation QuestionLoc,
2581 Expr *LHS,
2582 SourceLocation ColonLoc,
2583 Expr *RHS) {
2584 return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, Cond,
2585 LHS, RHS);
2586 }
2587
2588 /// Build a new C-style cast expression.
2589 ///
2590 /// By default, performs semantic analysis to build the new expression.
2591 /// Subclasses may override this routine to provide different behavior.
2592 ExprResult RebuildCStyleCastExpr(SourceLocation LParenLoc,
2593 TypeSourceInfo *TInfo,
2594 SourceLocation RParenLoc,
2595 Expr *SubExpr) {
2596 return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc,
2597 SubExpr);
2598 }
2599
2600 /// Build a new compound literal expression.
2601 ///
2602 /// By default, performs semantic analysis to build the new expression.
2603 /// Subclasses may override this routine to provide different behavior.
2604 ExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc,
2605 TypeSourceInfo *TInfo,
2606 SourceLocation RParenLoc,
2607 Expr *Init) {
2608 return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
2609 Init);
2610 }
2611
2612 /// Build a new extended vector element access expression.
2613 ///
2614 /// By default, performs semantic analysis to build the new expression.
2615 /// Subclasses may override this routine to provide different behavior.
2616 ExprResult RebuildExtVectorElementExpr(Expr *Base,
2617 SourceLocation OpLoc,
2618 SourceLocation AccessorLoc,
2619 IdentifierInfo &Accessor) {
2620
2621 CXXScopeSpec SS;
2622 DeclarationNameInfo NameInfo(&Accessor, AccessorLoc);
2623 return getSema().BuildMemberReferenceExpr(Base, Base->getType(),
2624 OpLoc, /*IsArrow*/ false,
2625 SS, SourceLocation(),
2626 /*FirstQualifierInScope*/ nullptr,
2627 NameInfo,
2628 /* TemplateArgs */ nullptr,
2629 /*S*/ nullptr);
2630 }
2631
2632 /// Build a new initializer list expression.
2633 ///
2634 /// By default, performs semantic analysis to build the new expression.
2635 /// Subclasses may override this routine to provide different behavior.
2636 ExprResult RebuildInitList(SourceLocation LBraceLoc,
2637 MultiExprArg Inits,
2638 SourceLocation RBraceLoc) {
2639 return SemaRef.BuildInitList(LBraceLoc, Inits, RBraceLoc);
2640 }
2641
2642 /// Build a new designated initializer expression.
2643 ///
2644 /// By default, performs semantic analysis to build the new expression.
2645 /// Subclasses may override this routine to provide different behavior.
2646 ExprResult RebuildDesignatedInitExpr(Designation &Desig,
2647 MultiExprArg ArrayExprs,
2648 SourceLocation EqualOrColonLoc,
2649 bool GNUSyntax,
2650 Expr *Init) {
2651 ExprResult Result
2652 = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
2653 Init);
2654 if (Result.isInvalid())
2655 return ExprError();
2656
2657 return Result;
2658 }
2659
2660 /// Build a new value-initialized expression.
2661 ///
2662 /// By default, builds the implicit value initialization without performing
2663 /// any semantic analysis. Subclasses may override this routine to provide
2664 /// different behavior.
2665 ExprResult RebuildImplicitValueInitExpr(QualType T) {
2666 return new (SemaRef.Context) ImplicitValueInitExpr(T);
2667 }
2668
2669 /// Build a new \c va_arg expression.
2670 ///
2671 /// By default, performs semantic analysis to build the new expression.
2672 /// Subclasses may override this routine to provide different behavior.
2673 ExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc,
2674 Expr *SubExpr, TypeSourceInfo *TInfo,
2675 SourceLocation RParenLoc) {
2676 return getSema().BuildVAArgExpr(BuiltinLoc,
2677 SubExpr, TInfo,
2678 RParenLoc);
2679 }
2680
2681 /// Build a new expression list in parentheses.
2682 ///
2683 /// By default, performs semantic analysis to build the new expression.
2684 /// Subclasses may override this routine to provide different behavior.
2685 ExprResult RebuildParenListExpr(SourceLocation LParenLoc,
2686 MultiExprArg SubExprs,
2687 SourceLocation RParenLoc) {
2688 return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, SubExprs);
2689 }
2690
2691 /// Build a new address-of-label expression.
2692 ///
2693 /// By default, performs semantic analysis, using the name of the label
2694 /// rather than attempting to map the label statement itself.
2695 /// Subclasses may override this routine to provide different behavior.
2696 ExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc,
2697 SourceLocation LabelLoc, LabelDecl *Label) {
2698 return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label);
2699 }
2700
2701 /// Build a new GNU statement expression.
2702 ///
2703 /// By default, performs semantic analysis to build the new expression.
2704 /// Subclasses may override this routine to provide different behavior.
2705 ExprResult RebuildStmtExpr(SourceLocation LParenLoc, Stmt *SubStmt,
2706 SourceLocation RParenLoc, unsigned TemplateDepth) {
2707 return getSema().BuildStmtExpr(LParenLoc, SubStmt, RParenLoc,
2708 TemplateDepth);
2709 }
2710
2711 /// Build a new __builtin_choose_expr expression.
2712 ///
2713 /// By default, performs semantic analysis to build the new expression.
2714 /// Subclasses may override this routine to provide different behavior.
2715 ExprResult RebuildChooseExpr(SourceLocation BuiltinLoc,
2716 Expr *Cond, Expr *LHS, Expr *RHS,
2717 SourceLocation RParenLoc) {
2718 return SemaRef.ActOnChooseExpr(BuiltinLoc,
2719 Cond, LHS, RHS,
2720 RParenLoc);
2721 }
2722
2723 /// Build a new generic selection expression.
2724 ///
2725 /// By default, performs semantic analysis to build the new expression.
2726 /// Subclasses may override this routine to provide different behavior.
2727 ExprResult RebuildGenericSelectionExpr(SourceLocation KeyLoc,
2728 SourceLocation DefaultLoc,
2729 SourceLocation RParenLoc,
2730 Expr *ControllingExpr,
2731 ArrayRef<TypeSourceInfo *> Types,
2732 ArrayRef<Expr *> Exprs) {
2733 return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
2734 ControllingExpr, Types, Exprs);
2735 }
2736
2737 /// Build a new overloaded operator call expression.
2738 ///
2739 /// By default, performs semantic analysis to build the new expression.
2740 /// The semantic analysis provides the behavior of template instantiation,
2741 /// copying with transformations that turn what looks like an overloaded
2742 /// operator call into a use of a builtin operator, performing
2743 /// argument-dependent lookup, etc. Subclasses may override this routine to
2744 /// provide different behavior.
2745 ExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
2746 SourceLocation OpLoc,
2747 Expr *Callee,
2748 Expr *First,
2749 Expr *Second);
2750
2751 /// Build a new C++ "named" cast expression, such as static_cast or
2752 /// reinterpret_cast.
2753 ///
2754 /// By default, this routine dispatches to one of the more-specific routines
2755 /// for a particular named case, e.g., RebuildCXXStaticCastExpr().
2756 /// Subclasses may override this routine to provide different behavior.
2757 ExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc,
2758 Stmt::StmtClass Class,
2759 SourceLocation LAngleLoc,
2760 TypeSourceInfo *TInfo,
2761 SourceLocation RAngleLoc,
2762 SourceLocation LParenLoc,
2763 Expr *SubExpr,
2764 SourceLocation RParenLoc) {
2765 switch (Class) {
2766 case Stmt::CXXStaticCastExprClass:
2767 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
2768 RAngleLoc, LParenLoc,
2769 SubExpr, RParenLoc);
2770
2771 case Stmt::CXXDynamicCastExprClass:
2772 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
2773 RAngleLoc, LParenLoc,
2774 SubExpr, RParenLoc);
2775
2776 case Stmt::CXXReinterpretCastExprClass:
2777 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
2778 RAngleLoc, LParenLoc,
2779 SubExpr,
2780 RParenLoc);
2781
2782 case Stmt::CXXConstCastExprClass:
2783 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
2784 RAngleLoc, LParenLoc,
2785 SubExpr, RParenLoc);
2786
2787 case Stmt::CXXAddrspaceCastExprClass:
2788 return getDerived().RebuildCXXAddrspaceCastExpr(
2789 OpLoc, LAngleLoc, TInfo, RAngleLoc, LParenLoc, SubExpr, RParenLoc);
2790
2791 default:
2792 llvm_unreachable("Invalid C++ named cast");
2793 }
2794 }
2795
2796 /// Build a new C++ static_cast expression.
2797 ///
2798 /// By default, performs semantic analysis to build the new expression.
2799 /// Subclasses may override this routine to provide different behavior.
2800 ExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc,
2801 SourceLocation LAngleLoc,
2802 TypeSourceInfo *TInfo,
2803 SourceLocation RAngleLoc,
2804 SourceLocation LParenLoc,
2805 Expr *SubExpr,
2806 SourceLocation RParenLoc) {
2807 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast,
2808 TInfo, SubExpr,
2809 SourceRange(LAngleLoc, RAngleLoc),
2810 SourceRange(LParenLoc, RParenLoc));
2811 }
2812
2813 /// Build a new C++ dynamic_cast expression.
2814 ///
2815 /// By default, performs semantic analysis to build the new expression.
2816 /// Subclasses may override this routine to provide different behavior.
2817 ExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc,
2818 SourceLocation LAngleLoc,
2819 TypeSourceInfo *TInfo,
2820 SourceLocation RAngleLoc,
2821 SourceLocation LParenLoc,
2822 Expr *SubExpr,
2823 SourceLocation RParenLoc) {
2824 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
2825 TInfo, SubExpr,
2826 SourceRange(LAngleLoc, RAngleLoc),
2827 SourceRange(LParenLoc, RParenLoc));
2828 }
2829
2830 /// Build a new C++ reinterpret_cast expression.
2831 ///
2832 /// By default, performs semantic analysis to build the new expression.
2833 /// Subclasses may override this routine to provide different behavior.
2834 ExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc,
2835 SourceLocation LAngleLoc,
2836 TypeSourceInfo *TInfo,
2837 SourceLocation RAngleLoc,
2838 SourceLocation LParenLoc,
2839 Expr *SubExpr,
2840 SourceLocation RParenLoc) {
2841 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
2842 TInfo, SubExpr,
2843 SourceRange(LAngleLoc, RAngleLoc),
2844 SourceRange(LParenLoc, RParenLoc));
2845 }
2846
2847 /// Build a new C++ const_cast expression.
2848 ///
2849 /// By default, performs semantic analysis to build the new expression.
2850 /// Subclasses may override this routine to provide different behavior.
2851 ExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc,
2852 SourceLocation LAngleLoc,
2853 TypeSourceInfo *TInfo,
2854 SourceLocation RAngleLoc,
2855 SourceLocation LParenLoc,
2856 Expr *SubExpr,
2857 SourceLocation RParenLoc) {
2858 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast,
2859 TInfo, SubExpr,
2860 SourceRange(LAngleLoc, RAngleLoc),
2861 SourceRange(LParenLoc, RParenLoc));
2862 }
2863
2864 ExprResult
2865 RebuildCXXAddrspaceCastExpr(SourceLocation OpLoc, SourceLocation LAngleLoc,
2866 TypeSourceInfo *TInfo, SourceLocation RAngleLoc,
2867 SourceLocation LParenLoc, Expr *SubExpr,
2868 SourceLocation RParenLoc) {
2869 return getSema().BuildCXXNamedCast(
2870 OpLoc, tok::kw_addrspace_cast, TInfo, SubExpr,
2871 SourceRange(LAngleLoc, RAngleLoc), SourceRange(LParenLoc, RParenLoc));
2872 }
2873
2874 /// Build a new C++ functional-style cast expression.
2875 ///
2876 /// By default, performs semantic analysis to build the new expression.
2877 /// Subclasses may override this routine to provide different behavior.
2878 ExprResult RebuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo,
2879 SourceLocation LParenLoc,
2880 Expr *Sub,
2881 SourceLocation RParenLoc,
2882 bool ListInitialization) {
2883 return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc,
2884 MultiExprArg(&Sub, 1), RParenLoc,
2885 ListInitialization);
2886 }
2887
2888 /// Build a new C++ __builtin_bit_cast expression.
2889 ///
2890 /// By default, performs semantic analysis to build the new expression.
2891 /// Subclasses may override this routine to provide different behavior.
2892 ExprResult RebuildBuiltinBitCastExpr(SourceLocation KWLoc,
2893 TypeSourceInfo *TSI, Expr *Sub,
2894 SourceLocation RParenLoc) {
2895 return getSema().BuildBuiltinBitCastExpr(KWLoc, TSI, Sub, RParenLoc);
2896 }
2897
2898 /// Build a new C++ typeid(type) expression.
2899 ///
2900 /// By default, performs semantic analysis to build the new expression.
2901 /// Subclasses may override this routine to provide different behavior.
2902 ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
2903 SourceLocation TypeidLoc,
2904 TypeSourceInfo *Operand,
2905 SourceLocation RParenLoc) {
2906 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
2907 RParenLoc);
2908 }
2909
2910
2911 /// Build a new C++ typeid(expr) expression.
2912 ///
2913 /// By default, performs semantic analysis to build the new expression.
2914 /// Subclasses may override this routine to provide different behavior.
2915 ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
2916 SourceLocation TypeidLoc,
2917 Expr *Operand,
2918 SourceLocation RParenLoc) {
2919 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
2920 RParenLoc);
2921 }
2922
2923 /// Build a new C++ __uuidof(type) expression.
2924 ///
2925 /// By default, performs semantic analysis to build the new expression.
2926 /// Subclasses may override this routine to provide different behavior.
2927 ExprResult RebuildCXXUuidofExpr(QualType Type, SourceLocation TypeidLoc,
2928 TypeSourceInfo *Operand,
2929 SourceLocation RParenLoc) {
2930 return getSema().BuildCXXUuidof(Type, TypeidLoc, Operand, RParenLoc);
2931 }
2932
2933 /// Build a new C++ __uuidof(expr) expression.
2934 ///
2935 /// By default, performs semantic analysis to build the new expression.
2936 /// Subclasses may override this routine to provide different behavior.
2937 ExprResult RebuildCXXUuidofExpr(QualType Type, SourceLocation TypeidLoc,
2938 Expr *Operand, SourceLocation RParenLoc) {
2939 return getSema().BuildCXXUuidof(Type, TypeidLoc, Operand, RParenLoc);
2940 }
2941
2942 /// Build a new C++ "this" expression.
2943 ///
2944 /// By default, builds a new "this" expression without performing any
2945 /// semantic analysis. Subclasses may override this routine to provide
2946 /// different behavior.
2947 ExprResult RebuildCXXThisExpr(SourceLocation ThisLoc,
2948 QualType ThisType,
2949 bool isImplicit) {
2950 return getSema().BuildCXXThisExpr(ThisLoc, ThisType, isImplicit);
2951 }
2952
2953 /// Build a new C++ throw expression.
2954 ///
2955 /// By default, performs semantic analysis to build the new expression.
2956 /// Subclasses may override this routine to provide different behavior.
2957 ExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, Expr *Sub,
2958 bool IsThrownVariableInScope) {
2959 return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope);
2960 }
2961
2962 /// Build a new C++ default-argument expression.
2963 ///
2964 /// By default, builds a new default-argument expression, which does not
2965 /// require any semantic analysis. Subclasses may override this routine to
2966 /// provide different behavior.
2967 ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc, ParmVarDecl *Param) {
2968 return CXXDefaultArgExpr::Create(getSema().Context, Loc, Param,
2969 getSema().CurContext);
2970 }
2971
2972 /// Build a new C++11 default-initialization expression.
2973 ///
2974 /// By default, builds a new default field initialization expression, which
2975 /// does not require any semantic analysis. Subclasses may override this
2976 /// routine to provide different behavior.
2977 ExprResult RebuildCXXDefaultInitExpr(SourceLocation Loc,
2978 FieldDecl *Field) {
2979 return CXXDefaultInitExpr::Create(getSema().Context, Loc, Field,
2980 getSema().CurContext);
2981 }
2982
2983 /// Build a new C++ zero-initialization expression.
2984 ///
2985 /// By default, performs semantic analysis to build the new expression.
2986 /// Subclasses may override this routine to provide different behavior.
2987 ExprResult RebuildCXXScalarValueInitExpr(TypeSourceInfo *TSInfo,
2988 SourceLocation LParenLoc,
2989 SourceLocation RParenLoc) {
2990 return getSema().BuildCXXTypeConstructExpr(
2991 TSInfo, LParenLoc, None, RParenLoc, /*ListInitialization=*/false);
2992 }
2993
2994 /// Build a new C++ "new" expression.
2995 ///
2996 /// By default, performs semantic analysis to build the new expression.
2997 /// Subclasses may override this routine to provide different behavior.
2998 ExprResult RebuildCXXNewExpr(SourceLocation StartLoc,
2999 bool UseGlobal,
3000 SourceLocation PlacementLParen,
3001 MultiExprArg PlacementArgs,
3002 SourceLocation PlacementRParen,
3003 SourceRange TypeIdParens,
3004 QualType AllocatedType,
3005 TypeSourceInfo *AllocatedTypeInfo,
3006 Optional<Expr *> ArraySize,
3007 SourceRange DirectInitRange,
3008 Expr *Initializer) {
3009 return getSema().BuildCXXNew(StartLoc, UseGlobal,
3010 PlacementLParen,
3011 PlacementArgs,
3012 PlacementRParen,
3013 TypeIdParens,
3014 AllocatedType,
3015 AllocatedTypeInfo,
3016 ArraySize,
3017 DirectInitRange,
3018 Initializer);
3019 }
3020
3021 /// Build a new C++ "delete" expression.
3022 ///
3023 /// By default, performs semantic analysis to build the new expression.
3024 /// Subclasses may override this routine to provide different behavior.
3025 ExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc,
3026 bool IsGlobalDelete,
3027 bool IsArrayForm,
3028 Expr *Operand) {
3029 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
3030 Operand);
3031 }
3032
3033 /// Build a new type trait expression.
3034 ///
3035 /// By default, performs semantic analysis to build the new expression.
3036 /// Subclasses may override this routine to provide different behavior.
3037 ExprResult RebuildTypeTrait(TypeTrait Trait,
3038 SourceLocation StartLoc,
3039 ArrayRef<TypeSourceInfo *> Args,
3040 SourceLocation RParenLoc) {
3041 return getSema().BuildTypeTrait(Trait, StartLoc, Args, RParenLoc);
3042 }
3043
3044 /// Build a new array type trait expression.
3045 ///
3046 /// By default, performs semantic analysis to build the new expression.
3047 /// Subclasses may override this routine to provide different behavior.
3048 ExprResult RebuildArrayTypeTrait(ArrayTypeTrait Trait,
3049 SourceLocation StartLoc,
3050 TypeSourceInfo *TSInfo,
3051 Expr *DimExpr,
3052 SourceLocation RParenLoc) {
3053 return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc);
3054 }
3055
3056 /// Build a new expression trait expression.
3057 ///
3058 /// By default, performs semantic analysis to build the new expression.
3059 /// Subclasses may override this routine to provide different behavior.
3060 ExprResult RebuildExpressionTrait(ExpressionTrait Trait,
3061 SourceLocation StartLoc,
3062 Expr *Queried,
3063 SourceLocation RParenLoc) {
3064 return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc);
3065 }
3066
3067 /// Build a new (previously unresolved) declaration reference
3068 /// expression.
3069 ///
3070 /// By default, performs semantic analysis to build the new expression.
3071 /// Subclasses may override this routine to provide different behavior.
3072 ExprResult RebuildDependentScopeDeclRefExpr(
3073 NestedNameSpecifierLoc QualifierLoc,
3074 SourceLocation TemplateKWLoc,
3075 const DeclarationNameInfo &NameInfo,
3076 const TemplateArgumentListInfo *TemplateArgs,
3077 bool IsAddressOfOperand,
3078 TypeSourceInfo **RecoveryTSI) {
3079 CXXScopeSpec SS;
3080 SS.Adopt(QualifierLoc);
3081
3082 if (TemplateArgs || TemplateKWLoc.isValid())
3083 return getSema().BuildQualifiedTemplateIdExpr(SS, TemplateKWLoc, NameInfo,
3084 TemplateArgs);
3085
3086 return getSema().BuildQualifiedDeclarationNameExpr(
3087 SS, NameInfo, IsAddressOfOperand, /*S*/nullptr, RecoveryTSI);
3088 }
3089
3090 /// Build a new template-id expression.
3091 ///
3092 /// By default, performs semantic analysis to build the new expression.
3093 /// Subclasses may override this routine to provide different behavior.
3094 ExprResult RebuildTemplateIdExpr(const CXXScopeSpec &SS,
3095 SourceLocation TemplateKWLoc,
3096 LookupResult &R,
3097 bool RequiresADL,
3098 const TemplateArgumentListInfo *TemplateArgs) {
3099 return getSema().BuildTemplateIdExpr(SS, TemplateKWLoc, R, RequiresADL,
3100 TemplateArgs);
3101 }
3102
3103 /// Build a new object-construction expression.
3104 ///
3105 /// By default, performs semantic analysis to build the new expression.
3106 /// Subclasses may override this routine to provide different behavior.
3107 ExprResult RebuildCXXConstructExpr(QualType T,
3108 SourceLocation Loc,
3109 CXXConstructorDecl *Constructor,
3110 bool IsElidable,
3111 MultiExprArg Args,
3112 bool HadMultipleCandidates,
3113 bool ListInitialization,
3114 bool StdInitListInitialization,
3115 bool RequiresZeroInit,
3116 CXXConstructExpr::ConstructionKind ConstructKind,
3117 SourceRange ParenRange) {
3118 // Reconstruct the constructor we originally found, which might be
3119 // different if this is a call to an inherited constructor.
3120 CXXConstructorDecl *FoundCtor = Constructor;
3121 if (Constructor->isInheritingConstructor())
3122 FoundCtor = Constructor->getInheritedConstructor().getConstructor();
3123
3124 SmallVector<Expr*, 8> ConvertedArgs;
3125 if (getSema().CompleteConstructorCall(FoundCtor, Args, Loc, ConvertedArgs))
3126 return ExprError();
3127
3128 return getSema().BuildCXXConstructExpr(Loc, T, Constructor,
3129 IsElidable,
3130 ConvertedArgs,
3131 HadMultipleCandidates,
3132 ListInitialization,
3133 StdInitListInitialization,
3134 RequiresZeroInit, ConstructKind,
3135 ParenRange);
3136 }
3137
3138 /// Build a new implicit construction via inherited constructor
3139 /// expression.
3140 ExprResult RebuildCXXInheritedCtorInitExpr(QualType T, SourceLocation Loc,
3141 CXXConstructorDecl *Constructor,
3142 bool ConstructsVBase,
3143 bool InheritedFromVBase) {
3144 return new (getSema().Context) CXXInheritedCtorInitExpr(
3145 Loc, T, Constructor, ConstructsVBase, InheritedFromVBase);
3146 }
3147
3148 /// Build a new object-construction expression.
3149 ///
3150 /// By default, performs semantic analysis to build the new expression.
3151 /// Subclasses may override this routine to provide different behavior.
3152 ExprResult RebuildCXXTemporaryObjectExpr(TypeSourceInfo *TSInfo,
3153 SourceLocation LParenOrBraceLoc,
3154 MultiExprArg Args,
3155 SourceLocation RParenOrBraceLoc,
3156 bool ListInitialization) {
3157 return getSema().BuildCXXTypeConstructExpr(
3158 TSInfo, LParenOrBraceLoc, Args, RParenOrBraceLoc, ListInitialization);
3159 }
3160
3161 /// Build a new object-construction expression.
3162 ///
3163 /// By default, performs semantic analysis to build the new expression.
3164 /// Subclasses may override this routine to provide different behavior.
3165 ExprResult RebuildCXXUnresolvedConstructExpr(TypeSourceInfo *TSInfo,
3166 SourceLocation LParenLoc,
3167 MultiExprArg Args,
3168 SourceLocation RParenLoc,
3169 bool ListInitialization) {
3170 return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc, Args,
3171 RParenLoc, ListInitialization);
3172 }
3173
3174 /// Build a new member reference expression.
3175 ///
3176 /// By default, performs semantic analysis to build the new expression.
3177 /// Subclasses may override this routine to provide different behavior.
3178 ExprResult RebuildCXXDependentScopeMemberExpr(Expr *BaseE,
3179 QualType BaseType,
3180 bool IsArrow,
3181 SourceLocation OperatorLoc,
3182 NestedNameSpecifierLoc QualifierLoc,
3183 SourceLocation TemplateKWLoc,
3184 NamedDecl *FirstQualifierInScope,
3185 const DeclarationNameInfo &MemberNameInfo,
3186 const TemplateArgumentListInfo *TemplateArgs) {
3187 CXXScopeSpec SS;
3188 SS.Adopt(QualifierLoc);
3189
3190 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
3191 OperatorLoc, IsArrow,
3192 SS, TemplateKWLoc,
3193 FirstQualifierInScope,
3194 MemberNameInfo,
3195 TemplateArgs, /*S*/nullptr);
3196 }
3197
3198 /// Build a new member reference expression.
3199 ///
3200 /// By default, performs semantic analysis to build the new expression.
3201 /// Subclasses may override this routine to provide different behavior.
3202 ExprResult RebuildUnresolvedMemberExpr(Expr *BaseE, QualType BaseType,
3203 SourceLocation OperatorLoc,
3204 bool IsArrow,
3205 NestedNameSpecifierLoc QualifierLoc,
3206 SourceLocation TemplateKWLoc,
3207 NamedDecl *FirstQualifierInScope,
3208 LookupResult &R,
3209 const TemplateArgumentListInfo *TemplateArgs) {
3210 CXXScopeSpec SS;
3211 SS.Adopt(QualifierLoc);
3212
3213 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
3214 OperatorLoc, IsArrow,
3215 SS, TemplateKWLoc,
3216 FirstQualifierInScope,
3217 R, TemplateArgs, /*S*/nullptr);
3218 }
3219
3220 /// Build a new noexcept expression.
3221 ///
3222 /// By default, performs semantic analysis to build the new expression.
3223 /// Subclasses may override this routine to provide different behavior.
3224 ExprResult RebuildCXXNoexceptExpr(SourceRange Range, Expr *Arg) {
3225 return SemaRef.BuildCXXNoexceptExpr(Range.getBegin(), Arg, Range.getEnd());
3226 }
3227
3228 /// Build a new expression to compute the length of a parameter pack.
3229 ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc,
3230 NamedDecl *Pack,
3231 SourceLocation PackLoc,
3232 SourceLocation RParenLoc,
3233 Optional<unsigned> Length,
3234 ArrayRef<TemplateArgument> PartialArgs) {
3235 return SizeOfPackExpr::Create(SemaRef.Context, OperatorLoc, Pack, PackLoc,
3236 RParenLoc, Length, PartialArgs);
3237 }
3238
3239 /// Build a new expression representing a call to a source location
3240 /// builtin.
3241 ///
3242 /// By default, performs semantic analysis to build the new expression.
3243 /// Subclasses may override this routine to provide different behavior.
3244 ExprResult RebuildSourceLocExpr(SourceLocExpr::IdentKind Kind,
3245 SourceLocation BuiltinLoc,
3246 SourceLocation RPLoc,
3247 DeclContext *ParentContext) {
3248 return getSema().BuildSourceLocExpr(Kind, BuiltinLoc, RPLoc, ParentContext);
3249 }
3250
3251 /// Build a new Objective-C boxed expression.
3252 ///
3253 /// By default, performs semantic analysis to build the new expression.
3254 /// Subclasses may override this routine to provide different behavior.
3255 ExprResult RebuildConceptSpecializationExpr(NestedNameSpecifierLoc NNS,
3256 SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo,
3257 NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
3258 TemplateArgumentListInfo *TALI) {
3259 CXXScopeSpec SS;
3260 SS.Adopt(NNS);
3261 ExprResult Result = getSema().CheckConceptTemplateId(SS, TemplateKWLoc,
3262 ConceptNameInfo,
3263 FoundDecl,
3264 NamedConcept, TALI);
3265 if (Result.isInvalid())
3266 return ExprError();
3267 return Result;
3268 }
3269
3270 /// \brief Build a new requires expression.
3271 ///
3272 /// By default, performs semantic analysis to build the new expression.
3273 /// Subclasses may override this routine to provide different behavior.
3274 ExprResult RebuildRequiresExpr(SourceLocation RequiresKWLoc,
3275 RequiresExprBodyDecl *Body,
3276 ArrayRef<ParmVarDecl *> LocalParameters,
3277 ArrayRef<concepts::Requirement *> Requirements,
3278 SourceLocation ClosingBraceLoc) {
3279 return RequiresExpr::Create(SemaRef.Context, RequiresKWLoc, Body,
3280 LocalParameters, Requirements, ClosingBraceLoc);
3281 }
3282
3283 concepts::TypeRequirement *
3284 RebuildTypeRequirement(
3285 concepts::Requirement::SubstitutionDiagnostic *SubstDiag) {
3286 return SemaRef.BuildTypeRequirement(SubstDiag);
3287 }
3288
3289 concepts::TypeRequirement *RebuildTypeRequirement(TypeSourceInfo *T) {
3290 return SemaRef.BuildTypeRequirement(T);
3291 }
3292
3293 concepts::ExprRequirement *
3294 RebuildExprRequirement(
3295 concepts::Requirement::SubstitutionDiagnostic *SubstDiag, bool IsSimple,
3296 SourceLocation NoexceptLoc,
3297 concepts::ExprRequirement::ReturnTypeRequirement Ret) {
3298 return SemaRef.BuildExprRequirement(SubstDiag, IsSimple, NoexceptLoc,
3299 std::move(Ret));
3300 }
3301
3302 concepts::ExprRequirement *
3303 RebuildExprRequirement(Expr *E, bool IsSimple, SourceLocation NoexceptLoc,
3304 concepts::ExprRequirement::ReturnTypeRequirement Ret) {
3305 return SemaRef.BuildExprRequirement(E, IsSimple, NoexceptLoc,
3306 std::move(Ret));
3307 }
3308
3309 concepts::NestedRequirement *
3310 RebuildNestedRequirement(
3311 concepts::Requirement::SubstitutionDiagnostic *SubstDiag) {
3312 return SemaRef.BuildNestedRequirement(SubstDiag);
3313 }
3314
3315 concepts::NestedRequirement *RebuildNestedRequirement(Expr *Constraint) {
3316 return SemaRef.BuildNestedRequirement(Constraint);
3317 }
3318
3319 /// \brief Build a new Objective-C boxed expression.
3320 ///
3321 /// By default, performs semantic analysis to build the new expression.
3322 /// Subclasses may override this routine to provide different behavior.
3323 ExprResult RebuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) {
3324 return getSema().BuildObjCBoxedExpr(SR, ValueExpr);
3325 }
3326
3327 /// Build a new Objective-C array literal.
3328 ///
3329 /// By default, performs semantic analysis to build the new expression.
3330 /// Subclasses may override this routine to provide different behavior.
3331 ExprResult RebuildObjCArrayLiteral(SourceRange Range,
3332 Expr **Elements, unsigned NumElements) {
3333 return getSema().BuildObjCArrayLiteral(Range,
3334 MultiExprArg(Elements, NumElements));
3335 }
3336
3337 ExprResult RebuildObjCSubscriptRefExpr(SourceLocation RB,
3338 Expr *Base, Expr *Key,
3339 ObjCMethodDecl *getterMethod,
3340 ObjCMethodDecl *setterMethod) {
3341 return getSema().BuildObjCSubscriptExpression(RB, Base, Key,
3342 getterMethod, setterMethod);
3343 }
3344
3345 /// Build a new Objective-C dictionary literal.
3346 ///
3347 /// By default, performs semantic analysis to build the new expression.
3348 /// Subclasses may override this routine to provide different behavior.
3349 ExprResult RebuildObjCDictionaryLiteral(SourceRange Range,
3350 MutableArrayRef<ObjCDictionaryElement> Elements) {
3351 return getSema().BuildObjCDictionaryLiteral(Range, Elements);
3352 }
3353
3354 /// Build a new Objective-C \@encode expression.
3355 ///
3356 /// By default, performs semantic analysis to build the new expression.
3357 /// Subclasses may override this routine to provide different behavior.
3358 ExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc,
3359 TypeSourceInfo *EncodeTypeInfo,
3360 SourceLocation RParenLoc) {
3361 return SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo, RParenLoc);
3362 }
3363
3364 /// Build a new Objective-C class message.
3365 ExprResult RebuildObjCMessageExpr(TypeSourceInfo *ReceiverTypeInfo,
3366 Selector Sel,
3367 ArrayRef<SourceLocation> SelectorLocs,
3368 ObjCMethodDecl *Method,
3369 SourceLocation LBracLoc,
3370 MultiExprArg Args,
3371 SourceLocation RBracLoc) {
3372 return SemaRef.BuildClassMessage(ReceiverTypeInfo,
3373 ReceiverTypeInfo->getType(),
3374 /*SuperLoc=*/SourceLocation(),
3375 Sel, Method, LBracLoc, SelectorLocs,
3376 RBracLoc, Args);
3377 }
3378
3379 /// Build a new Objective-C instance message.
3380 ExprResult RebuildObjCMessageExpr(Expr *Receiver,
3381 Selector Sel,
3382 ArrayRef<SourceLocation> SelectorLocs,
3383 ObjCMethodDecl *Method,
3384 SourceLocation LBracLoc,
3385 MultiExprArg Args,
3386 SourceLocation RBracLoc) {
3387 return SemaRef.BuildInstanceMessage(Receiver,
3388 Receiver->getType(),
3389 /*SuperLoc=*/SourceLocation(),
3390 Sel, Method, LBracLoc, SelectorLocs,
3391 RBracLoc, Args);
3392 }
3393
3394 /// Build a new Objective-C instance/class message to 'super'.
3395 ExprResult RebuildObjCMessageExpr(SourceLocation SuperLoc,
3396 Selector Sel,
3397 ArrayRef<SourceLocation> SelectorLocs,
3398 QualType SuperType,
3399 ObjCMethodDecl *Method,
3400 SourceLocation LBracLoc,
3401 MultiExprArg Args,
3402 SourceLocation RBracLoc) {
3403 return Method->isInstanceMethod() ? SemaRef.BuildInstanceMessage(nullptr,
3404 SuperType,
3405 SuperLoc,
3406 Sel, Method, LBracLoc, SelectorLocs,
3407 RBracLoc, Args)
3408 : SemaRef.BuildClassMessage(nullptr,
3409 SuperType,
3410 SuperLoc,
3411 Sel, Method, LBracLoc, SelectorLocs,
3412 RBracLoc, Args);
3413
3414
3415 }
3416
3417 /// Build a new Objective-C ivar reference expression.
3418 ///
3419 /// By default, performs semantic analysis to build the new expression.
3420 /// Subclasses may override this routine to provide different behavior.
3421 ExprResult RebuildObjCIvarRefExpr(Expr *BaseArg, ObjCIvarDecl *Ivar,
3422 SourceLocation IvarLoc,
3423 bool IsArrow, bool IsFreeIvar) {
3424 CXXScopeSpec SS;
3425 DeclarationNameInfo NameInfo(Ivar->getDeclName(), IvarLoc);
3426 ExprResult Result = getSema().BuildMemberReferenceExpr(
3427 BaseArg, BaseArg->getType(),
3428 /*FIXME:*/ IvarLoc, IsArrow, SS, SourceLocation(),
3429 /*FirstQualifierInScope=*/nullptr, NameInfo,
3430 /*TemplateArgs=*/nullptr,
3431 /*S=*/nullptr);
3432 if (IsFreeIvar && Result.isUsable())
3433 cast<ObjCIvarRefExpr>(Result.get())->setIsFreeIvar(IsFreeIvar);
3434 return Result;
3435 }
3436
3437 /// Build a new Objective-C property reference expression.
3438 ///
3439 /// By default, performs semantic analysis to build the new expression.
3440 /// Subclasses may override this routine to provide different behavior.
3441 ExprResult RebuildObjCPropertyRefExpr(Expr *BaseArg,
3442 ObjCPropertyDecl *Property,
3443 SourceLocation PropertyLoc) {
3444 CXXScopeSpec SS;
3445 DeclarationNameInfo NameInfo(Property->getDeclName(), PropertyLoc);
3446 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(),
3447 /*FIXME:*/PropertyLoc,
3448 /*IsArrow=*/false,
3449 SS, SourceLocation(),
3450 /*FirstQualifierInScope=*/nullptr,
3451 NameInfo,
3452 /*TemplateArgs=*/nullptr,
3453 /*S=*/nullptr);
3454 }
3455
3456 /// Build a new Objective-C property reference expression.
3457 ///
3458 /// By default, performs semantic analysis to build the new expression.
3459 /// Subclasses may override this routine to provide different behavior.
3460 ExprResult RebuildObjCPropertyRefExpr(Expr *Base, QualType T,
3461 ObjCMethodDecl *Getter,
3462 ObjCMethodDecl *Setter,
3463 SourceLocation PropertyLoc) {
3464 // Since these expressions can only be value-dependent, we do not
3465 // need to perform semantic analysis again.
3466 return Owned(
3467 new (getSema().Context) ObjCPropertyRefExpr(Getter, Setter, T,
3468 VK_LValue, OK_ObjCProperty,
3469 PropertyLoc, Base));
3470 }
3471
3472 /// Build a new Objective-C "isa" expression.
3473 ///
3474 /// By default, performs semantic analysis to build the new expression.
3475 /// Subclasses may override this routine to provide different behavior.
3476 ExprResult RebuildObjCIsaExpr(Expr *BaseArg, SourceLocation IsaLoc,
3477 SourceLocation OpLoc, bool IsArrow) {
3478 CXXScopeSpec SS;
3479 DeclarationNameInfo NameInfo(&getSema().Context.Idents.get("isa"), IsaLoc);
3480 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(),
3481 OpLoc, IsArrow,
3482 SS, SourceLocation(),
3483 /*FirstQualifierInScope=*/nullptr,
3484 NameInfo,
3485 /*TemplateArgs=*/nullptr,
3486 /*S=*/nullptr);
3487 }
3488
3489 /// Build a new shuffle vector expression.
3490 ///
3491 /// By default, performs semantic analysis to build the new expression.
3492 /// Subclasses may override this routine to provide different behavior.
3493 ExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc,
3494 MultiExprArg SubExprs,
3495 SourceLocation RParenLoc) {
3496 // Find the declaration for __builtin_shufflevector
3497 const IdentifierInfo &Name
3498 = SemaRef.Context.Idents.get("__builtin_shufflevector");
3499 TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl();
3500 DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name));
3501 assert(!Lookup.empty() && "No __builtin_shufflevector?");
3502
3503 // Build a reference to the __builtin_shufflevector builtin
3504 FunctionDecl *Builtin = cast<FunctionDecl>(Lookup.front());
3505 Expr *Callee = new (SemaRef.Context)
3506 DeclRefExpr(SemaRef.Context, Builtin, false,
3507 SemaRef.Context.BuiltinFnTy, VK_RValue, BuiltinLoc);
3508 QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType());
3509 Callee = SemaRef.ImpCastExprToType(Callee, CalleePtrTy,
3510 CK_BuiltinFnToFnPtr).get();
3511
3512 // Build the CallExpr
3513 ExprResult TheCall = CallExpr::Create(
3514 SemaRef.Context, Callee, SubExprs, Builtin->getCallResultType(),
3515 Expr::getValueKindForType(Builtin->getReturnType()), RParenLoc,
3516 FPOptionsOverride());
3517
3518 // Type-check the __builtin_shufflevector expression.
3519 return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.get()));
3520 }
3521
3522 /// Build a new convert vector expression.
3523 ExprResult RebuildConvertVectorExpr(SourceLocation BuiltinLoc,
3524 Expr *SrcExpr, TypeSourceInfo *DstTInfo,
3525 SourceLocation RParenLoc) {
3526 return SemaRef.SemaConvertVectorExpr(SrcExpr, DstTInfo,
3527 BuiltinLoc, RParenLoc);
3528 }
3529
3530 /// Build a new template argument pack expansion.
3531 ///
3532 /// By default, performs semantic analysis to build a new pack expansion
3533 /// for a template argument. Subclasses may override this routine to provide
3534 /// different behavior.
3535 TemplateArgumentLoc RebuildPackExpansion(TemplateArgumentLoc Pattern,
3536 SourceLocation EllipsisLoc,
3537 Optional<unsigned> NumExpansions) {
3538 switch (Pattern.getArgument().getKind()) {
3539 case TemplateArgument::Expression: {
3540 ExprResult Result
3541 = getSema().CheckPackExpansion(Pattern.getSourceExpression(),
3542 EllipsisLoc, NumExpansions);
3543 if (Result.isInvalid())
3544 return TemplateArgumentLoc();
3545
3546 return TemplateArgumentLoc(Result.get(), Result.get());
3547 }
3548
3549 case TemplateArgument::Template:
3550 return TemplateArgumentLoc(
3551 SemaRef.Context,
3552 TemplateArgument(Pattern.getArgument().getAsTemplate(),
3553 NumExpansions),
3554 Pattern.getTemplateQualifierLoc(), Pattern.getTemplateNameLoc(),
3555 EllipsisLoc);
3556
3557 case TemplateArgument::Null:
3558 case TemplateArgument::Integral:
3559 case TemplateArgument::Declaration:
3560 case TemplateArgument::Pack:
3561 case TemplateArgument::TemplateExpansion:
3562 case TemplateArgument::NullPtr:
3563 llvm_unreachable("Pack expansion pattern has no parameter packs");
3564
3565 case TemplateArgument::Type:
3566 if (TypeSourceInfo *Expansion
3567 = getSema().CheckPackExpansion(Pattern.getTypeSourceInfo(),
3568 EllipsisLoc,
3569 NumExpansions))
3570 return TemplateArgumentLoc(TemplateArgument(Expansion->getType()),
3571 Expansion);
3572 break;
3573 }
3574
3575 return TemplateArgumentLoc();
3576 }
3577
3578 /// Build a new expression pack expansion.
3579 ///
3580 /// By default, performs semantic analysis to build a new pack expansion
3581 /// for an expression. Subclasses may override this routine to provide
3582 /// different behavior.
3583 ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
3584 Optional<unsigned> NumExpansions) {
3585 return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions);
3586 }
3587
3588 /// Build a new C++1z fold-expression.
3589 ///
3590 /// By default, performs semantic analysis in order to build a new fold
3591 /// expression.
3592 ExprResult RebuildCXXFoldExpr(UnresolvedLookupExpr *ULE,
3593 SourceLocation LParenLoc, Expr *LHS,
3594 BinaryOperatorKind Operator,
3595 SourceLocation EllipsisLoc, Expr *RHS,
3596 SourceLocation RParenLoc,
3597 Optional<unsigned> NumExpansions) {
3598 return getSema().BuildCXXFoldExpr(ULE, LParenLoc, LHS, Operator,
3599 EllipsisLoc, RHS, RParenLoc,
3600 NumExpansions);
3601 }
3602
3603 /// Build an empty C++1z fold-expression with the given operator.
3604 ///
3605 /// By default, produces the fallback value for the fold-expression, or
3606 /// produce an error if there is no fallback value.
3607 ExprResult RebuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,
3608 BinaryOperatorKind Operator) {
3609 return getSema().BuildEmptyCXXFoldExpr(EllipsisLoc, Operator);
3610 }
3611
3612 /// Build a new atomic operation expression.
3613 ///
3614 /// By default, performs semantic analysis to build the new expression.
3615 /// Subclasses may override this routine to provide different behavior.
3616 ExprResult RebuildAtomicExpr(SourceLocation BuiltinLoc, MultiExprArg SubExprs,
3617 AtomicExpr::AtomicOp Op,
3618 SourceLocation RParenLoc) {
3619 // Use this for all of the locations, since we don't know the difference
3620 // between the call and the expr at this point.
3621 SourceRange Range{BuiltinLoc, RParenLoc};
3622 return getSema().BuildAtomicExpr(Range, Range, RParenLoc, SubExprs, Op,
3623 Sema::AtomicArgumentOrder::AST);
3624 }
3625
3626 ExprResult RebuildRecoveryExpr(SourceLocation BeginLoc, SourceLocation EndLoc,
3627 ArrayRef<Expr *> SubExprs, QualType Type) {
3628 return getSema().CreateRecoveryExpr(BeginLoc, EndLoc, SubExprs, Type);
3629 }
3630
3631private:
3632 TypeLoc TransformTypeInObjectScope(TypeLoc TL,
3633 QualType ObjectType,
3634 NamedDecl *FirstQualifierInScope,
3635 CXXScopeSpec &SS);
3636
3637 TypeSourceInfo *TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
3638 QualType ObjectType,
3639 NamedDecl *FirstQualifierInScope,
3640 CXXScopeSpec &SS);
3641
3642 TypeSourceInfo *TransformTSIInObjectScope(TypeLoc TL, QualType ObjectType,
3643 NamedDecl *FirstQualifierInScope,
3644 CXXScopeSpec &SS);
3645
3646 QualType TransformDependentNameType(TypeLocBuilder &TLB,
3647 DependentNameTypeLoc TL,
3648 bool DeducibleTSTContext);
3649};
3650
3651template <typename Derived>
3652StmtResult TreeTransform<Derived>::TransformStmt(Stmt *S, StmtDiscardKind SDK) {
3653 if (!S)
3654 return S;
3655
3656 switch (S->getStmtClass()) {
3657 case Stmt::NoStmtClass: break;
3658
3659 // Transform individual statement nodes
3660 // Pass SDK into statements that can produce a value
3661#define STMT(Node, Parent) \
3662 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
3663#define VALUESTMT(Node, Parent) \
3664 case Stmt::Node##Class: \
3665 return getDerived().Transform##Node(cast<Node>(S), SDK);
3666#define ABSTRACT_STMT(Node)
3667#define EXPR(Node, Parent)
3668#include "clang/AST/StmtNodes.inc"
3669
3670 // Transform expressions by calling TransformExpr.
3671#define STMT(Node, Parent)
3672#define ABSTRACT_STMT(Stmt)
3673#define EXPR(Node, Parent) case Stmt::Node##Class:
3674#include "clang/AST/StmtNodes.inc"
3675 {
3676 ExprResult E = getDerived().TransformExpr(cast<Expr>(S));
3677
3678 if (SDK == SDK_StmtExprResult)
3679 E = getSema().ActOnStmtExprResult(E);
3680 return getSema().ActOnExprStmt(E, SDK == SDK_Discarded);
3681 }
3682 }
3683
3684 return S;
3685}
3686
3687template<typename Derived>
3688OMPClause *TreeTransform<Derived>::TransformOMPClause(OMPClause *S) {
3689 if (!S)
3690 return S;
3691
3692 switch (S->getClauseKind()) {
3693 default: break;
3694 // Transform individual clause nodes
3695#define GEN_CLANG_CLAUSE_CLASS
3696#define CLAUSE_CLASS(Enum, Str, Class) \
3697 case Enum: \
3698 return getDerived().Transform##Class(cast<Class>(S));
3699#include "llvm/Frontend/OpenMP/OMP.inc"
3700 }
3701
3702 return S;
3703}
3704
3705
3706template<typename Derived>
3707ExprResult TreeTransform<Derived>::TransformExpr(Expr *E) {
3708 if (!E)
3709 return E;
3710
3711 switch (E->getStmtClass()) {
3712 case Stmt::NoStmtClass: break;
3713#define STMT(Node, Parent) case Stmt::Node##Class: break;
3714#define ABSTRACT_STMT(Stmt)
3715#define EXPR(Node, Parent) \
3716 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
3717#include "clang/AST/StmtNodes.inc"
3718 }
3719
3720 return E;
3721}
3722
3723template<typename Derived>
3724ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init,
3725 bool NotCopyInit) {
3726 // Initializers are instantiated like expressions, except that various outer
3727 // layers are stripped.
3728 if (!Init)
3729 return Init;
3730
3731 if (auto *FE = dyn_cast<FullExpr>(Init))
3732 Init = FE->getSubExpr();
3733
3734 if (auto *AIL = dyn_cast<ArrayInitLoopExpr>(Init))
3735 Init = AIL->getCommonExpr();
3736
3737 if (MaterializeTemporaryExpr *MTE = dyn_cast<MaterializeTemporaryExpr>(Init))
3738 Init = MTE->getSubExpr();
3739
3740 while (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(Init))
3741 Init = Binder->getSubExpr();
3742
3743 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Init))
3744 Init = ICE->getSubExprAsWritten();
3745
3746 if (CXXStdInitializerListExpr *ILE =
3747 dyn_cast<CXXStdInitializerListExpr>(Init))
3748 return TransformInitializer(ILE->getSubExpr(), NotCopyInit);
3749
3750 // If this is copy-initialization, we only need to reconstruct
3751 // InitListExprs. Other forms of copy-initialization will be a no-op if
3752 // the initializer is already the right type.
3753 CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init);
3754 if (!NotCopyInit && !(Construct && Construct->isListInitialization()))
3755 return getDerived().TransformExpr(Init);
3756
3757 // Revert value-initialization back to empty parens.
3758 if (CXXScalarValueInitExpr *VIE = dyn_cast<CXXScalarValueInitExpr>(Init)) {
3759 SourceRange Parens = VIE->getSourceRange();
3760 return getDerived().RebuildParenListExpr(Parens.getBegin(), None,
3761 Parens.getEnd());
3762 }
3763
3764 // FIXME: We shouldn't build ImplicitValueInitExprs for direct-initialization.
3765 if (isa<ImplicitValueInitExpr>(Init))
3766 return getDerived().RebuildParenListExpr(SourceLocation(), None,
3767 SourceLocation());
3768
3769 // Revert initialization by constructor back to a parenthesized or braced list
3770 // of expressions. Any other form of initializer can just be reused directly.
3771 if (!Construct || isa<CXXTemporaryObjectExpr>(Construct))
3772 return getDerived().TransformExpr(Init);
3773
3774 // If the initialization implicitly converted an initializer list to a
3775 // std::initializer_list object, unwrap the std::initializer_list too.
3776 if (Construct && Construct->isStdInitListInitialization())
3777 return TransformInitializer(Construct->getArg(0), NotCopyInit);
3778
3779 // Enter a list-init context if this was list initialization.
3780 EnterExpressionEvaluationContext Context(
3781 getSema(), EnterExpressionEvaluationContext::InitList,
3782 Construct->isListInitialization());
3783
3784 SmallVector<Expr*, 8> NewArgs;
3785 bool ArgChanged = false;
3786 if (getDerived().TransformExprs(Construct->getArgs(), Construct->getNumArgs(),
3787 /*IsCall*/true, NewArgs, &ArgChanged))
3788 return ExprError();
3789
3790 // If this was list initialization, revert to syntactic list form.
3791 if (Construct->isListInitialization())
3792 return getDerived().RebuildInitList(Construct->getBeginLoc(), NewArgs,
3793 Construct->getEndLoc());
3794
3795 // Build a ParenListExpr to represent anything else.
3796 SourceRange Parens = Construct->getParenOrBraceRange();
3797 if (Parens.isInvalid()) {
3798 // This was a variable declaration's initialization for which no initializer
3799 // was specified.
3800 assert(NewArgs.empty() &&
3801 "no parens or braces but have direct init with arguments?");
3802 return ExprEmpty();
3803 }
3804 return getDerived().RebuildParenListExpr(Parens.getBegin(), NewArgs,
3805 Parens.getEnd());
3806}
3807
3808template<typename Derived>
3809bool TreeTransform<Derived>::TransformExprs(Expr *const *Inputs,
3810 unsigned NumInputs,
3811 bool IsCall,
3812 SmallVectorImpl<Expr *> &Outputs,
3813 bool *ArgChanged) {
3814 for (unsigned I = 0; I != NumInputs; ++I) {
3815 // If requested, drop call arguments that need to be dropped.
3816 if (IsCall && getDerived().DropCallArgument(Inputs[I])) {
3817 if (ArgChanged)
3818 *ArgChanged = true;
3819
3820 break;
3821 }
3822
3823 if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(Inputs[I])) {
3824 Expr *Pattern = Expansion->getPattern();
3825
3826 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
3827 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
3828 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
3829
3830 // Determine whether the set of unexpanded parameter packs can and should
3831 // be expanded.
3832 bool Expand = true;
3833 bool RetainExpansion = false;
3834 Optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions();
3835 Optional<unsigned> NumExpansions = OrigNumExpansions;
3836 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
3837 Pattern->getSourceRange(),
3838 Unexpanded,
3839 Expand, RetainExpansion,
3840 NumExpansions))
3841 return true;
3842
3843 if (!Expand) {
3844 // The transform has determined that we should perform a simple
3845 // transformation on the pack expansion, producing another pack
3846 // expansion.
3847 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
3848 ExprResult OutPattern = getDerived().TransformExpr(Pattern);
3849 if (OutPattern.isInvalid())
3850 return true;
3851
3852 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.get(),
3853 Expansion->getEllipsisLoc(),
3854 NumExpansions);
3855 if (Out.isInvalid())
3856 return true;
3857
3858 if (ArgChanged)
3859 *ArgChanged = true;
3860 Outputs.push_back(Out.get());
3861 continue;
3862 }
3863
3864 // Record right away that the argument was changed. This needs
3865 // to happen even if the array expands to nothing.
3866 if (ArgChanged) *ArgChanged = true;
3867
3868 // The transform has determined that we should perform an elementwise
3869 // expansion of the pattern. Do so.
3870 for (unsigned I = 0; I != *NumExpansions; ++I) {
3871 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
3872 ExprResult Out = getDerived().TransformExpr(Pattern);
3873 if (Out.isInvalid())
3874 return true;
3875
3876 if (Out.get()->containsUnexpandedParameterPack()) {
3877 Out = getDerived().RebuildPackExpansion(
3878 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
3879 if (Out.isInvalid())
3880 return true;
3881 }
3882
3883 Outputs.push_back(Out.get());
3884 }
3885
3886 // If we're supposed to retain a pack expansion, do so by temporarily
3887 // forgetting the partially-substituted parameter pack.
3888 if (RetainExpansion) {
3889 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
3890
3891 ExprResult Out = getDerived().TransformExpr(Pattern);
3892 if (Out.isInvalid())
3893 return true;
3894
3895 Out = getDerived().RebuildPackExpansion(
3896 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
3897 if (Out.isInvalid())
3898 return true;
3899
3900 Outputs.push_back(Out.get());
3901 }
3902
3903 continue;
3904 }
3905
3906 ExprResult Result =
3907 IsCall ? getDerived().TransformInitializer(Inputs[I], /*DirectInit*/false)
3908 : getDerived().TransformExpr(Inputs[I]);
3909 if (Result.isInvalid())
3910 return true;
3911
3912 if (Result.get() != Inputs[I] && ArgChanged)
3913 *ArgChanged = true;
3914
3915 Outputs.push_back(Result.get());
3916 }
3917
3918 return false;
3919}
3920
3921template <typename Derived>
3922Sema::ConditionResult TreeTransform<Derived>::TransformCondition(
3923 SourceLocation Loc, VarDecl *Var, Expr *Expr, Sema::ConditionKind Kind) {
3924 if (Var) {
3925 VarDecl *ConditionVar = cast_or_null<VarDecl>(
3926 getDerived().TransformDefinition(Var->getLocation(), Var));
3927
3928 if (!ConditionVar)
3929 return Sema::ConditionError();
3930
3931 return getSema().ActOnConditionVariable(ConditionVar, Loc, Kind);
3932 }
3933
3934 if (Expr) {
3935 ExprResult CondExpr = getDerived().TransformExpr(Expr);
3936
3937 if (CondExpr.isInvalid())
3938 return Sema::ConditionError();
3939
3940 return getSema().ActOnCondition(nullptr, Loc, CondExpr.get(), Kind);
3941 }
3942
3943 return Sema::ConditionResult();
3944}
3945
3946template<typename Derived>
3947NestedNameSpecifierLoc
3948TreeTransform<Derived>::TransformNestedNameSpecifierLoc(
3949 NestedNameSpecifierLoc NNS,
3950 QualType ObjectType,
3951 NamedDecl *FirstQualifierInScope) {
3952 SmallVector<NestedNameSpecifierLoc, 4> Qualifiers;
3953 for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier;
3954 Qualifier = Qualifier.getPrefix())
3955 Qualifiers.push_back(Qualifier);
3956
3957 CXXScopeSpec SS;
3958 while (!Qualifiers.empty()) {
3959 NestedNameSpecifierLoc Q = Qualifiers.pop_back_val();
3960 NestedNameSpecifier *QNNS = Q.getNestedNameSpecifier();
3961
3962 switch (QNNS->getKind()) {
3963 case NestedNameSpecifier::Identifier: {
3964 Sema::NestedNameSpecInfo IdInfo(QNNS->getAsIdentifier(),
3965 Q.getLocalBeginLoc(), Q.getLocalEndLoc(), ObjectType);
3966 if (SemaRef.BuildCXXNestedNameSpecifier(/*Scope=*/nullptr, IdInfo, false,
3967 SS, FirstQualifierInScope, false))
3968 return NestedNameSpecifierLoc();
3969 }
3970 break;
3971
3972 case NestedNameSpecifier::Namespace: {
3973 NamespaceDecl *NS
3974 = cast_or_null<NamespaceDecl>(
3975 getDerived().TransformDecl(
3976 Q.getLocalBeginLoc(),
3977 QNNS->getAsNamespace()));
3978 SS.Extend(SemaRef.Context, NS, Q.getLocalBeginLoc(), Q.getLocalEndLoc());
3979 break;
3980 }
3981
3982 case NestedNameSpecifier::NamespaceAlias: {
3983 NamespaceAliasDecl *Alias
3984 = cast_or_null<NamespaceAliasDecl>(
3985 getDerived().TransformDecl(Q.getLocalBeginLoc(),
3986 QNNS->getAsNamespaceAlias()));
3987 SS.Extend(SemaRef.Context, Alias, Q.getLocalBeginLoc(),
3988 Q.getLocalEndLoc());
3989 break;
3990 }
3991
3992 case NestedNameSpecifier::Global:
3993 // There is no meaningful transformation that one could perform on the
3994 // global scope.
3995 SS.MakeGlobal(SemaRef.Context, Q.getBeginLoc());
3996 break;
3997
3998 case NestedNameSpecifier::Super: {
3999 CXXRecordDecl *RD =
4000 cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
4001 SourceLocation(), QNNS->getAsRecordDecl()));
4002 SS.MakeSuper(SemaRef.Context, RD, Q.getBeginLoc(), Q.getEndLoc());
4003 break;
4004 }
4005
4006 case NestedNameSpecifier::TypeSpecWithTemplate:
4007 case NestedNameSpecifier::TypeSpec: {
4008 TypeLoc TL = TransformTypeInObjectScope(Q.getTypeLoc(), ObjectType,
4009 FirstQualifierInScope, SS);
4010
4011 if (!TL)
4012 return NestedNameSpecifierLoc();
4013
4014 if (TL.getType()->isDependentType() || TL.getType()->isRecordType() ||
4015 (SemaRef.getLangOpts().CPlusPlus11 &&
4016 TL.getType()->isEnumeralType())) {
4017 assert(!TL.getType().hasLocalQualifiers() &&
4018 "Can't get cv-qualifiers here");
4019 if (TL.getType()->isEnumeralType())
4020 SemaRef.Diag(TL.getBeginLoc(),
4021 diag::warn_cxx98_compat_enum_nested_name_spec);
4022 SS.Extend(SemaRef.Context, /*FIXME:*/SourceLocation(), TL,
4023 Q.getLocalEndLoc());
4024 break;
4025 }
4026 // If the nested-name-specifier is an invalid type def, don't emit an
4027 // error because a previous error should have already been emitted.
4028 TypedefTypeLoc TTL = TL.getAs<TypedefTypeLoc>();
4029 if (!TTL || !TTL.getTypedefNameDecl()->isInvalidDecl()) {
4030 SemaRef.Diag(TL.getBeginLoc(), diag::err_nested_name_spec_non_tag)
4031 << TL.getType() << SS.getRange();
4032 }
4033 return NestedNameSpecifierLoc();
4034 }
4035 }
4036
4037 // The qualifier-in-scope and object type only apply to the leftmost entity.
4038 FirstQualifierInScope = nullptr;
4039 ObjectType = QualType();
4040 }
4041
4042 // Don't rebuild the nested-name-specifier if we don't have to.
4043 if (SS.getScopeRep() == NNS.getNestedNameSpecifier() &&
4044 !getDerived().AlwaysRebuild())
4045 return NNS;
4046
4047 // If we can re-use the source-location data from the original
4048 // nested-name-specifier, do so.
4049 if (SS.location_size() == NNS.getDataLength() &&
4050 memcmp(SS.location_data(), NNS.getOpaqueData(), SS.location_size()) == 0)
4051 return NestedNameSpecifierLoc(SS.getScopeRep(), NNS.getOpaqueData());
4052
4053 // Allocate new nested-name-specifier location information.
4054 return SS.getWithLocInContext(SemaRef.Context);
4055}
4056
4057template<typename Derived>
4058DeclarationNameInfo
4059TreeTransform<Derived>
4060::TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo) {
4061 DeclarationName Name = NameInfo.getName();
4062 if (!Name)
4063 return DeclarationNameInfo();
4064
4065 switch (Name.getNameKind()) {
4066 case DeclarationName::Identifier:
4067 case DeclarationName::ObjCZeroArgSelector:
4068 case DeclarationName::ObjCOneArgSelector:
4069 case DeclarationName::ObjCMultiArgSelector:
4070 case DeclarationName::CXXOperatorName:
4071 case DeclarationName::CXXLiteralOperatorName:
4072 case DeclarationName::CXXUsingDirective:
4073 return NameInfo;
4074
4075 case DeclarationName::CXXDeductionGuideName: {
4076 TemplateDecl *OldTemplate = Name.getCXXDeductionGuideTemplate();
4077 TemplateDecl *NewTemplate = cast_or_null<TemplateDecl>(
4078 getDerived().TransformDecl(NameInfo.getLoc(), OldTemplate));
4079 if (!NewTemplate)
4080 return DeclarationNameInfo();
4081
4082 DeclarationNameInfo NewNameInfo(NameInfo);
4083 NewNameInfo.setName(
4084 SemaRef.Context.DeclarationNames.getCXXDeductionGuideName(NewTemplate));
4085 return NewNameInfo;
4086 }
4087
4088 case DeclarationName::CXXConstructorName:
4089 case DeclarationName::CXXDestructorName:
4090 case DeclarationName::CXXConversionFunctionName: {
4091 TypeSourceInfo *NewTInfo;
4092 CanQualType NewCanTy;
4093 if (TypeSourceInfo *OldTInfo = NameInfo.getNamedTypeInfo()) {
4094 NewTInfo = getDerived().TransformType(OldTInfo);
4095 if (!NewTInfo)
4096 return DeclarationNameInfo();
4097 NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->getType());
4098 }
4099 else {
4100 NewTInfo = nullptr;
4101 TemporaryBase Rebase(*this, NameInfo.getLoc(), Name);
4102 QualType NewT = getDerived().TransformType(Name.getCXXNameType());
4103 if (NewT.isNull())
4104 return DeclarationNameInfo();
4105 NewCanTy = SemaRef.Context.getCanonicalType(NewT);
4106 }
4107
4108 DeclarationName NewName
4109 = SemaRef.Context.DeclarationNames.getCXXSpecialName(Name.getNameKind(),
4110 NewCanTy);
4111 DeclarationNameInfo NewNameInfo(NameInfo);
4112 NewNameInfo.setName(NewName);
4113 NewNameInfo.setNamedTypeInfo(NewTInfo);
4114 return NewNameInfo;
4115 }
4116 }
4117
4118 llvm_unreachable("Unknown name kind.");
4119}
4120
4121template<typename Derived>
4122TemplateName
4123TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS,
4124 TemplateName Name,
4125 SourceLocation NameLoc,
4126 QualType ObjectType,
4127 NamedDecl *FirstQualifierInScope,
4128 bool AllowInjectedClassName) {
4129 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) {
4130 TemplateDecl *Template = QTN->getTemplateDecl();
4131 assert(Template && "qualified template name must refer to a template");
4132
4133 TemplateDecl *TransTemplate
4134 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
4135 Template));
4136 if (!TransTemplate)
4137 return TemplateName();
4138
4139 if (!getDerived().AlwaysRebuild() &&
4140 SS.getScopeRep() == QTN->getQualifier() &&
4141 TransTemplate == Template)
4142 return Name;
4143
4144 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
4145 TransTemplate);
4146 }
4147
4148 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) {
4149 if (SS.getScopeRep()) {
4150 // These apply to the scope specifier, not the template.
4151 ObjectType = QualType();
4152 FirstQualifierInScope = nullptr;
4153 }
4154
4155 if (!getDerived().AlwaysRebuild() &&
4156 SS.getScopeRep() == DTN->getQualifier() &&
4157 ObjectType.isNull())
4158 return Name;
4159
4160 // FIXME: Preserve the location of the "template" keyword.
4161 SourceLocation TemplateKWLoc = NameLoc;
4162
4163 if (DTN->isIdentifier()) {
4164 return getDerived().RebuildTemplateName(SS,
4165 TemplateKWLoc,
4166 *DTN->getIdentifier(),
4167 NameLoc,
4168 ObjectType,
4169 FirstQualifierInScope,
4170 AllowInjectedClassName);
4171 }
4172
4173 return getDerived().RebuildTemplateName(SS, TemplateKWLoc,
4174 DTN->getOperator(), NameLoc,
4175 ObjectType, AllowInjectedClassName);
4176 }
4177
4178 if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
4179 TemplateDecl *TransTemplate
4180 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
4181 Template));
4182 if (!TransTemplate)
4183 return TemplateName();
4184
4185 if (!getDerived().AlwaysRebuild() &&
4186 TransTemplate == Template)
4187 return Name;
4188
4189 return TemplateName(TransTemplate);
4190 }
4191
4192 if (SubstTemplateTemplateParmPackStorage *SubstPack
4193 = Name.getAsSubstTemplateTemplateParmPack()) {
4194 TemplateTemplateParmDecl *TransParam
4195 = cast_or_null<TemplateTemplateParmDecl>(
4196 getDerived().TransformDecl(NameLoc, SubstPack->getParameterPack()));
4197 if (!TransParam)
4198 return TemplateName();
4199
4200 if (!getDerived().AlwaysRebuild() &&
4201 TransParam == SubstPack->getParameterPack())
4202 return Name;
4203
4204 return getDerived().RebuildTemplateName(TransParam,
4205 SubstPack->getArgumentPack());
4206 }
4207
4208 // These should be getting filtered out before they reach the AST.
4209 llvm_unreachable("overloaded function decl survived to here");
4210}
4211
4212template<typename Derived>
4213void TreeTransform<Derived>::InventTemplateArgumentLoc(
4214 const TemplateArgument &Arg,
4215 TemplateArgumentLoc &Output) {
4216 Output = getSema().getTrivialTemplateArgumentLoc(
4217 Arg, QualType(), getDerived().getBaseLocation());
4218}
4219
4220template<typename Derived>
4221bool TreeTransform<Derived>::TransformTemplateArgument(
4222 const TemplateArgumentLoc &Input,
4223 TemplateArgumentLoc &Output, bool Uneval) {
4224 const TemplateArgument &Arg = Input.getArgument();
4225 switch (Arg.getKind()) {
4226 case TemplateArgument::Null:
4227 case TemplateArgument::Pack:
4228 llvm_unreachable("Unexpected TemplateArgument");
4229
4230 case TemplateArgument::Integral:
4231 case TemplateArgument::NullPtr:
4232 case TemplateArgument::Declaration: {
4233 // Transform a resolved template argument straight to a resolved template
4234 // argument. We get here when substituting into an already-substituted
4235 // template type argument during concept satisfaction checking.
4236 QualType T = Arg.getNonTypeTemplateArgumentType();
4237 QualType NewT = getDerived().TransformType(T);
4238 if (NewT.isNull())
4239 return true;
4240
4241 ValueDecl *D = Arg.getKind() == TemplateArgument::Declaration
4242 ? Arg.getAsDecl()
4243 : nullptr;
4244 ValueDecl *NewD = D ? cast_or_null<ValueDecl>(getDerived().TransformDecl(
4245 getDerived().getBaseLocation(), D))
4246 : nullptr;
4247 if (D && !NewD)
4248 return true;
4249
4250 if (NewT == T && D == NewD)
4251 Output = Input;
4252 else if (Arg.getKind() == TemplateArgument::Integral)
4253 Output = TemplateArgumentLoc(
4254 TemplateArgument(getSema().Context, Arg.getAsIntegral(), NewT),
4255 TemplateArgumentLocInfo());
4256 else if (Arg.getKind() == TemplateArgument::NullPtr)
4257 Output = TemplateArgumentLoc(TemplateArgument(NewT, /*IsNullPtr=*/true),
4258 TemplateArgumentLocInfo());
4259 else
4260 Output = TemplateArgumentLoc(TemplateArgument(NewD, NewT),
4261 TemplateArgumentLocInfo());
4262
4263 return false;
4264 }
4265
4266 case TemplateArgument::Type: {
4267 TypeSourceInfo *DI = Input.getTypeSourceInfo();
4268 if (!DI)
4269 DI = InventTypeSourceInfo(Input.getArgument().getAsType());
4270
4271 DI = getDerived().TransformType(DI);
4272 if (!DI) return true;
4273
4274 Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
4275 return false;
4276 }
4277
4278 case TemplateArgument::Template: {
4279 NestedNameSpecifierLoc QualifierLoc = Input.getTemplateQualifierLoc();
4280 if (QualifierLoc) {
4281 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
4282 if (!QualifierLoc)
4283 return true;
4284 }
4285
4286 CXXScopeSpec SS;
4287 SS.Adopt(QualifierLoc);
4288 TemplateName Template
4289 = getDerived().TransformTemplateName(SS, Arg.getAsTemplate(),
4290 Input.getTemplateNameLoc());
4291 if (Template.isNull())
4292 return true;
4293
4294 Output = TemplateArgumentLoc(SemaRef.Context, TemplateArgument(Template),
4295 QualifierLoc, Input.getTemplateNameLoc());
4296 return false;
4297 }
4298
4299 case TemplateArgument::TemplateExpansion:
4300 llvm_unreachable("Caller should expand pack expansions");
4301
4302 case TemplateArgument::Expression: {
4303 // Template argument expressions are constant expressions.
4304 EnterExpressionEvaluationContext Unevaluated(
4305 getSema(),
4306 Uneval ? Sema::ExpressionEvaluationContext::Unevaluated
4307 : Sema::ExpressionEvaluationContext::ConstantEvaluated,
4308 /*LambdaContextDecl=*/nullptr, /*ExprContext=*/
4309 Sema::ExpressionEvaluationContextRecord::EK_TemplateArgument);
4310
4311 Expr *InputExpr = Input.getSourceExpression();
4312 if (!InputExpr) InputExpr = Input.getArgument().getAsExpr();
4313
4314 ExprResult E = getDerived().TransformExpr(InputExpr);
4315 E = SemaRef.ActOnConstantExpression(E);
4316 if (E.isInvalid()) return true;
4317 Output = TemplateArgumentLoc(TemplateArgument(E.get()), E.get());
4318 return false;
4319 }
4320 }
4321
4322 // Work around bogus GCC warning
4323 return true;
4324}
4325
4326/// Iterator adaptor that invents template argument location information
4327/// for each of the template arguments in its underlying iterator.
4328template<typename Derived, typename InputIterator>
4329class TemplateArgumentLocInventIterator {
4330 TreeTransform<Derived> &Self;
4331 InputIterator Iter;
4332
4333public:
4334 typedef TemplateArgumentLoc value_type;
4335 typedef TemplateArgumentLoc reference;
4336 typedef typename std::iterator_traits<InputIterator>::difference_type
4337 difference_type;
4338 typedef std::input_iterator_tag iterator_category;
4339
4340 class pointer {
4341 TemplateArgumentLoc Arg;
4342
4343 public:
4344 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { }
4345
4346 const TemplateArgumentLoc *operator->() const { return &Arg; }
4347 };
4348
4349 TemplateArgumentLocInventIterator() { }
4350
4351 explicit TemplateArgumentLocInventIterator(TreeTransform<Derived> &Self,
4352 InputIterator Iter)
4353 : Self(Self), Iter(Iter) { }
4354
4355 TemplateArgumentLocInventIterator &operator++() {
4356 ++Iter;
4357 return *this;
4358 }
4359
4360 TemplateArgumentLocInventIterator operator++(int) {
4361 TemplateArgumentLocInventIterator Old(*this);
4362 ++(*this);
4363 return Old;
4364 }
4365
4366 reference operator*() const {
4367 TemplateArgumentLoc Result;
4368 Self.InventTemplateArgumentLoc(*Iter, Result);
4369 return Result;
4370 }
4371
4372 pointer operator->() const { return pointer(**this); }
4373
4374 friend bool operator==(const TemplateArgumentLocInventIterator &X,
4375 const TemplateArgumentLocInventIterator &Y) {
4376 return X.Iter == Y.Iter;
4377 }
4378
4379 friend bool operator!=(const TemplateArgumentLocInventIterator &X,
4380 const TemplateArgumentLocInventIterator &Y) {
4381 return X.Iter != Y.Iter;
4382 }
4383};
4384
4385template<typename Derived>
4386template<typename InputIterator>
4387bool TreeTransform<Derived>::TransformTemplateArguments(
4388 InputIterator First, InputIterator Last, TemplateArgumentListInfo &Outputs,
4389 bool Uneval) {
4390 for (; First != Last; ++First) {
4391 TemplateArgumentLoc Out;
4392 TemplateArgumentLoc In = *First;
4393
4394 if (In.getArgument().getKind() == TemplateArgument::Pack) {
4395 // Unpack argument packs, which we translate them into separate
4396 // arguments.
4397 // FIXME: We could do much better if we could guarantee that the
4398 // TemplateArgumentLocInfo for the pack expansion would be usable for
4399 // all of the template arguments in the argument pack.
4400 typedef TemplateArgumentLocInventIterator<Derived,
4401 TemplateArgument::pack_iterator>
4402 PackLocIterator;
4403 if (TransformTemplateArguments(PackLocIterator(*this,
4404 In.getArgument().pack_begin()),
4405 PackLocIterator(*this,
4406 In.getArgument().pack_end()),
4407 Outputs, Uneval))
4408 return true;
4409
4410 continue;
4411 }
4412
4413 if (In.getArgument().isPackExpansion()) {
4414 // We have a pack expansion, for which we will be substituting into
4415 // the pattern.
4416 SourceLocation Ellipsis;
4417 Optional<unsigned> OrigNumExpansions;
4418 TemplateArgumentLoc Pattern
4419 = getSema().getTemplateArgumentPackExpansionPattern(
4420 In, Ellipsis, OrigNumExpansions);
4421
4422 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
4423 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
4424 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
4425
4426 // Determine whether the set of unexpanded parameter packs can and should
4427 // be expanded.
4428 bool Expand = true;
4429 bool RetainExpansion = false;
4430 Optional<unsigned> NumExpansions = OrigNumExpansions;
4431 if (getDerived().TryExpandParameterPacks(Ellipsis,
4432 Pattern.getSourceRange(),
4433 Unexpanded,
4434 Expand,
4435 RetainExpansion,
4436 NumExpansions))
4437 return true;
4438
4439 if (!Expand) {
4440 // The transform has determined that we should perform a simple
4441 // transformation on the pack expansion, producing another pack
4442 // expansion.
4443 TemplateArgumentLoc OutPattern;
4444 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
4445 if (getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval))
4446 return true;
4447
4448 Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis,
4449 NumExpansions);
4450 if (Out.getArgument().isNull())
4451 return true;
4452
4453 Outputs.addArgument(Out);
4454 continue;
4455 }
4456
4457 // The transform has determined that we should perform an elementwise
4458 // expansion of the pattern. Do so.
4459 for (unsigned I = 0; I != *NumExpansions; ++I) {
4460 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
4461
4462 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
4463 return true;
4464
4465 if (Out.getArgument().containsUnexpandedParameterPack()) {
4466 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
4467 OrigNumExpansions);
4468 if (Out.getArgument().isNull())
4469 return true;
4470 }
4471
4472 Outputs.addArgument(Out);
4473 }
4474
4475 // If we're supposed to retain a pack expansion, do so by temporarily
4476 // forgetting the partially-substituted parameter pack.
4477 if (RetainExpansion) {
4478 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4479
4480 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
4481 return true;
4482
4483 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
4484 OrigNumExpansions);
4485 if (Out.getArgument().isNull())
4486 return true;
4487
4488 Outputs.addArgument(Out);
4489 }
4490
4491 continue;
4492 }
4493
4494 // The simple case:
4495 if (getDerived().TransformTemplateArgument(In, Out, Uneval))
4496 return true;
4497
4498 Outputs.addArgument(Out);
4499 }
4500
4501 return false;
4502
4503}
4504
4505//===----------------------------------------------------------------------===//
4506// Type transformation
4507//===----------------------------------------------------------------------===//
4508
4509template<typename Derived>
4510QualType TreeTransform<Derived>::TransformType(QualType T) {
4511 if (getDerived().AlreadyTransformed(T))
4512 return T;
4513
4514 // Temporary workaround. All of these transformations should
4515 // eventually turn into transformations on TypeLocs.
4516 TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T,
4517 getDerived().getBaseLocation());
4518
4519 TypeSourceInfo *NewDI = getDerived().TransformType(DI);
4520
4521 if (!NewDI)
4522 return QualType();
4523
4524 return NewDI->getType();
4525}
4526
4527template<typename Derived>
4528TypeSourceInfo *TreeTransform<Derived>::TransformType(TypeSourceInfo *DI) {
4529 // Refine the base location to the type's location.
4530 TemporaryBase Rebase(*this, DI->getTypeLoc().getBeginLoc(),
4531 getDerived().getBaseEntity());
4532 if (getDerived().AlreadyTransformed(DI->getType()))
4533 return DI;
4534
4535 TypeLocBuilder TLB;
4536
4537 TypeLoc TL = DI->getTypeLoc();
4538 TLB.reserve(TL.getFullDataSize());
4539
4540 QualType Result = getDerived().TransformType(TLB, TL);
4541 if (Result.isNull())
4542 return nullptr;
4543
4544 return TLB.getTypeSourceInfo(SemaRef.Context, Result);
4545}
4546
4547template<typename Derived>
4548QualType
4549TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) {
4550 switch (T.getTypeLocClass()) {
4551#define ABSTRACT_TYPELOC(CLASS, PARENT)
4552#define TYPELOC(CLASS, PARENT) \
4553 case TypeLoc::CLASS: \
4554 return getDerived().Transform##CLASS##Type(TLB, \
4555 T.castAs<CLASS##TypeLoc>());
4556#include "clang/AST/TypeLocNodes.def"
4557 }
4558
4559 llvm_unreachable("unhandled type loc!");
4560}
4561
4562template<typename Derived>
4563QualType TreeTransform<Derived>::TransformTypeWithDeducedTST(QualType T) {
4564 if (!isa<DependentNameType>(T))
4565 return TransformType(T);
4566
4567 if (getDerived().AlreadyTransformed(T))
4568 return T;
4569 TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T,
4570 getDerived().getBaseLocation());
4571 TypeSourceInfo *NewDI = getDerived().TransformTypeWithDeducedTST(DI);
4572 return NewDI ? NewDI->getType() : QualType();
4573}
4574
4575template<typename Derived>
4576TypeSourceInfo *
4577TreeTransform<Derived>::TransformTypeWithDeducedTST(TypeSourceInfo *DI) {
4578 if (!isa<DependentNameType>(DI->getType()))
4579 return TransformType(DI);
4580
4581 // Refine the base location to the type's location.
4582 TemporaryBase Rebase(*this, DI->getTypeLoc().getBeginLoc(),
4583 getDerived().getBaseEntity());
4584 if (getDerived().AlreadyTransformed(DI->getType()))
4585 return DI;
4586
4587 TypeLocBuilder TLB;
4588
4589 TypeLoc TL = DI->getTypeLoc();
4590 TLB.reserve(TL.getFullDataSize());
4591
4592 auto QTL = TL.getAs<QualifiedTypeLoc>();
4593 if (QTL)
4594 TL = QTL.getUnqualifiedLoc();
4595
4596 auto DNTL = TL.castAs<DependentNameTypeLoc>();
4597
4598 QualType Result = getDerived().TransformDependentNameType(
4599 TLB, DNTL, /*DeducedTSTContext*/true);
4600 if (Result.isNull())
4601 return nullptr;
4602
4603 if (QTL) {
4604 Result = getDerived().RebuildQualifiedType(Result, QTL);
4605 if (Result.isNull())
4606 return nullptr;
4607 TLB.TypeWasModifiedSafely(Result);
4608 }
4609
4610 return TLB.getTypeSourceInfo(SemaRef.Context, Result);
4611}
4612
4613template<typename Derived>
4614QualType
4615TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB,
4616 QualifiedTypeLoc T) {
4617 QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc());
4618 if (Result.isNull())
4619 return QualType();
4620
4621 Result = getDerived().RebuildQualifiedType(Result, T);
4622
4623 if (Result.isNull())
4624 return QualType();
4625
4626 // RebuildQualifiedType might have updated the type, but not in a way
4627 // that invalidates the TypeLoc. (There's no location information for
4628 // qualifiers.)
4629 TLB.TypeWasModifiedSafely(Result);
4630
4631 return Result;
4632}
4633
4634template <typename Derived>
4635QualType TreeTransform<Derived>::RebuildQualifiedType(QualType T,
4636 QualifiedTypeLoc TL) {
4637
4638 SourceLocation Loc = TL.getBeginLoc();
4639 Qualifiers Quals = TL.getType().getLocalQualifiers();
4640
4641 if (((T.getAddressSpace() != LangAS::Default &&
4642 Quals.getAddressSpace() != LangAS::Default)) &&
4643 T.getAddressSpace() != Quals.getAddressSpace()) {
4644 SemaRef.Diag(Loc, diag::err_address_space_mismatch_templ_inst)
4645 << TL.getType() << T;
4646 return QualType();
4647 }
4648
4649 // C++ [dcl.fct]p7:
4650 // [When] adding cv-qualifications on top of the function type [...] the
4651 // cv-qualifiers are ignored.
4652 if (T->isFunctionType()) {
4653 T = SemaRef.getASTContext().getAddrSpaceQualType(T,
4654 Quals.getAddressSpace());
4655 return T;
4656 }
4657
4658 // C++ [dcl.ref]p1:
4659 // when the cv-qualifiers are introduced through the use of a typedef-name
4660 // or decltype-specifier [...] the cv-qualifiers are ignored.
4661 // Note that [dcl.ref]p1 lists all cases in which cv-qualifiers can be
4662 // applied to a reference type.
4663 if (T->isReferenceType()) {
4664 // The only qualifier that applies to a reference type is restrict.
4665 if (!Quals.hasRestrict())
4666 return T;
4667 Quals = Qualifiers::fromCVRMask(Qualifiers::Restrict);
4668 }
4669
4670 // Suppress Objective-C lifetime qualifiers if they don't make sense for the
4671 // resulting type.
4672 if (Quals.hasObjCLifetime()) {
4673 if (!T->isObjCLifetimeType() && !T->isDependentType())
4674 Quals.removeObjCLifetime();
4675 else if (T.getObjCLifetime()) {
4676 // Objective-C ARC:
4677 // A lifetime qualifier applied to a substituted template parameter
4678 // overrides the lifetime qualifier from the template argument.
4679 const AutoType *AutoTy;
4680 if (const SubstTemplateTypeParmType *SubstTypeParam
4681 = dyn_cast<SubstTemplateTypeParmType>(T)) {
4682 QualType Replacement = SubstTypeParam->getReplacementType();
4683 Qualifiers Qs = Replacement.getQualifiers();
4684 Qs.removeObjCLifetime();
4685 Replacement = SemaRef.Context.getQualifiedType(
4686 Replacement.getUnqualifiedType(), Qs);
4687 T = SemaRef.Context.getSubstTemplateTypeParmType(
4688 SubstTypeParam->getReplacedParameter(), Replacement);
4689 } else if ((AutoTy = dyn_cast<AutoType>(T)) && AutoTy->isDeduced()) {
4690 // 'auto' types behave the same way as template parameters.
4691 QualType Deduced = AutoTy->getDeducedType();
4692 Qualifiers Qs = Deduced.getQualifiers();
4693 Qs.removeObjCLifetime();
4694 Deduced =
4695 SemaRef.Context.getQualifiedType(Deduced.getUnqualifiedType(), Qs);
4696 T = SemaRef.Context.getAutoType(Deduced, AutoTy->getKeyword(),
4697 AutoTy->isDependentType(),
4698 /*isPack=*/false,
4699 AutoTy->getTypeConstraintConcept(),
4700 AutoTy->getTypeConstraintArguments());
4701 } else {
4702 // Otherwise, complain about the addition of a qualifier to an
4703 // already-qualified type.
4704 // FIXME: Why is this check not in Sema::BuildQualifiedType?
4705 SemaRef.Diag(Loc, diag::err_attr_objc_ownership_redundant) << T;
4706 Quals.removeObjCLifetime();
4707 }
4708 }
4709 }
4710
4711 return SemaRef.BuildQualifiedType(T, Loc, Quals);
4712}
4713
4714template<typename Derived>
4715TypeLoc
4716TreeTransform<Derived>::TransformTypeInObjectScope(TypeLoc TL,
4717 QualType ObjectType,
4718 NamedDecl *UnqualLookup,
4719 CXXScopeSpec &SS) {
4720 if (getDerived().AlreadyTransformed(TL.getType()))
4721 return TL;
4722
4723 TypeSourceInfo *TSI =
4724 TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS);
4725 if (TSI)
4726 return TSI->getTypeLoc();
4727 return TypeLoc();
4728}
4729
4730template<typename Derived>
4731TypeSourceInfo *
4732TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
4733 QualType ObjectType,
4734 NamedDecl *UnqualLookup,
4735 CXXScopeSpec &SS) {
4736 if (getDerived().AlreadyTransformed(TSInfo->getType()))
4737 return TSInfo;
4738
4739 return TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType,
4740 UnqualLookup, SS);
4741}
4742
4743template <typename Derived>
4744TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope(
4745 TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup,
4746 CXXScopeSpec &SS) {
4747 QualType T = TL.getType();
4748 assert(!getDerived().AlreadyTransformed(T));
4749
4750 TypeLocBuilder TLB;
4751 QualType Result;
4752
4753 if (isa<TemplateSpecializationType>(T)) {
4754 TemplateSpecializationTypeLoc SpecTL =
4755 TL.castAs<TemplateSpecializationTypeLoc>();
4756
4757 TemplateName Template = getDerived().TransformTemplateName(
4758 SS, SpecTL.getTypePtr()->getTemplateName(), SpecTL.getTemplateNameLoc(),
4759 ObjectType, UnqualLookup, /*AllowInjectedClassName*/true);
4760 if (Template.isNull())
4761 return nullptr;
4762
4763 Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL,
4764 Template);
4765 } else if (isa<DependentTemplateSpecializationType>(T)) {
4766 DependentTemplateSpecializationTypeLoc SpecTL =
4767 TL.castAs<DependentTemplateSpecializationTypeLoc>();
4768
4769 TemplateName Template
4770 = getDerived().RebuildTemplateName(SS,
4771 SpecTL.getTemplateKeywordLoc(),
4772 *SpecTL.getTypePtr()->getIdentifier(),
4773 SpecTL.getTemplateNameLoc(),
4774 ObjectType, UnqualLookup,
4775 /*AllowInjectedClassName*/true);
4776 if (Template.isNull())
4777 return nullptr;
4778
4779 Result = getDerived().TransformDependentTemplateSpecializationType(TLB,
4780 SpecTL,
4781 Template,
4782 SS);
4783 } else {
4784 // Nothing special needs to be done for these.
4785 Result = getDerived().TransformType(TLB, TL);
4786 }
4787
4788 if (Result.isNull())
4789 return nullptr;
4790
4791 return TLB.getTypeSourceInfo(SemaRef.Context, Result);
4792}
4793
4794template <class TyLoc> static inline
4795QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) {
4796 TyLoc NewT = TLB.push<TyLoc>(T.getType());
4797 NewT.setNameLoc(T.getNameLoc());
4798 return T.getType();
4799}
4800
4801template<typename Derived>
4802QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
4803 BuiltinTypeLoc T) {
4804 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType());
4805 NewT.setBuiltinLoc(T.getBuiltinLoc());
4806 if (T.needsExtraLocalData())
4807 NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs();
4808 return T.getType();
4809}
4810
4811template<typename Derived>
4812QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
4813 ComplexTypeLoc T) {
4814 // FIXME: recurse?
4815 return TransformTypeSpecType(TLB, T);
4816}
4817
4818template <typename Derived>
4819QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB,
4820 AdjustedTypeLoc TL) {
4821 // Adjustments applied during transformation are handled elsewhere.
4822 return getDerived().TransformType(TLB, TL.getOriginalLoc());
4823}
4824
4825template<typename Derived>
4826QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB,
4827 DecayedTypeLoc TL) {
4828 QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc());
4829 if (OriginalType.isNull())
4830 return QualType();
4831
4832 QualType Result = TL.getType();
4833 if (getDerived().AlwaysRebuild() ||
4834 OriginalType != TL.getOriginalLoc().getType())
4835 Result = SemaRef.Context.getDecayedType(OriginalType);
4836 TLB.push<DecayedTypeLoc>(Result);
4837 // Nothing to set for DecayedTypeLoc.
4838 return Result;
4839}
4840
4841template<typename Derived>
4842QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
4843 PointerTypeLoc TL) {
4844 QualType PointeeType
4845 = getDerived().TransformType(TLB, TL.getPointeeLoc());
4846 if (PointeeType.isNull())
4847 return QualType();
4848
4849 QualType Result = TL.getType();
4850 if (PointeeType->getAs<ObjCObjectType>()) {
4851 // A dependent pointer type 'T *' has is being transformed such
4852 // that an Objective-C class type is being replaced for 'T'. The
4853 // resulting pointer type is an ObjCObjectPointerType, not a
4854 // PointerType.
4855 Result = SemaRef.Context.getObjCObjectPointerType(PointeeType);
4856
4857 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
4858 NewT.setStarLoc(TL.getStarLoc());
4859 return Result;
4860 }
4861
4862 if (getDerived().AlwaysRebuild() ||
4863 PointeeType != TL.getPointeeLoc().getType()) {
4864 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc());
4865 if (Result.isNull())
4866 return QualType();
4867 }
4868
4869 // Objective-C ARC can add lifetime qualifiers to the type that we're
4870 // pointing to.
4871 TLB.TypeWasModifiedSafely(Result->getPointeeType());
4872
4873 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result);
4874 NewT.setSigilLoc(TL.getSigilLoc());
4875 return Result;
4876}
4877
4878template<typename Derived>
4879QualType
4880TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
4881 BlockPointerTypeLoc TL) {
4882 QualType PointeeType
4883 = getDerived().TransformType(TLB, TL.getPointeeLoc());
4884 if (PointeeType.isNull())
4885 return QualType();
4886
4887 QualType Result = TL.getType();
4888 if (getDerived().AlwaysRebuild() ||
4889 PointeeType != TL.getPointeeLoc().getType()) {
4890 Result = getDerived().RebuildBlockPointerType(PointeeType,
4891 TL.getSigilLoc());
4892 if (Result.isNull())
4893 return QualType();
4894 }
4895
4896 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result);
4897 NewT.setSigilLoc(TL.getSigilLoc());
4898 return Result;
4899}
4900
4901/// Transforms a reference type. Note that somewhat paradoxically we
4902/// don't care whether the type itself is an l-value type or an r-value
4903/// type; we only care if the type was *written* as an l-value type
4904/// or an r-value type.
4905template<typename Derived>
4906QualType
4907TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB,
4908 ReferenceTypeLoc TL) {
4909 const ReferenceType *T = TL.getTypePtr();
4910
4911 // Note that this works with the pointee-as-written.
4912 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
4913 if (PointeeType.isNull())
4914 return QualType();
4915
4916 QualType Result = TL.getType();
4917 if (getDerived().AlwaysRebuild() ||
4918 PointeeType != T->getPointeeTypeAsWritten()) {
4919 Result = getDerived().RebuildReferenceType(PointeeType,
4920 T->isSpelledAsLValue(),
4921 TL.getSigilLoc());
4922 if (Result.isNull())
4923 return QualType();
4924 }
4925
4926 // Objective-C ARC can add lifetime qualifiers to the type that we're
4927 // referring to.
4928 TLB.TypeWasModifiedSafely(
4929 Result->castAs<ReferenceType>()->getPointeeTypeAsWritten());
4930
4931 // r-value references can be rebuilt as l-value references.
4932 ReferenceTypeLoc NewTL;
4933 if (isa<LValueReferenceType>(Result))
4934 NewTL = TLB.push<LValueReferenceTypeLoc>(Result);
4935 else
4936 NewTL = TLB.push<RValueReferenceTypeLoc>(Result);
4937 NewTL.setSigilLoc(TL.getSigilLoc());
4938
4939 return Result;
4940}
4941
4942template<typename Derived>
4943QualType
4944TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB,
4945 LValueReferenceTypeLoc TL) {
4946 return TransformReferenceType(TLB, TL);
4947}
4948
4949template<typename Derived>
4950QualType
4951TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
4952 RValueReferenceTypeLoc TL) {
4953 return TransformReferenceType(TLB, TL);
4954}
4955
4956template<typename Derived>
4957QualType
4958TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
4959 MemberPointerTypeLoc TL) {
4960 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
4961 if (PointeeType.isNull())
4962 return QualType();
4963
4964 TypeSourceInfo* OldClsTInfo = TL.getClassTInfo();
4965 TypeSourceInfo *NewClsTInfo = nullptr;
4966 if (OldClsTInfo) {
4967 NewClsTInfo = getDerived().TransformType(OldClsTInfo);
4968 if (!NewClsTInfo)
4969 return QualType();
4970 }
4971
4972 const MemberPointerType *T = TL.getTypePtr();
4973 QualType OldClsType = QualType(T->getClass(), 0);
4974 QualType NewClsType;
4975 if (NewClsTInfo)
4976 NewClsType = NewClsTInfo->getType();
4977 else {
4978 NewClsType = getDerived().TransformType(OldClsType);
4979 if (NewClsType.isNull())
4980 return QualType();
4981 }
4982
4983 QualType Result = TL.getType();
4984 if (getDerived().AlwaysRebuild() ||
4985 PointeeType != T->getPointeeType() ||
4986 NewClsType != OldClsType) {
4987 Result = getDerived().RebuildMemberPointerType(PointeeType, NewClsType,
4988 TL.getStarLoc());
4989 if (Result.isNull())
4990 return QualType();
4991 }
4992
4993 // If we had to adjust the pointee type when building a member pointer, make
4994 // sure to push TypeLoc info for it.
4995 const MemberPointerType *MPT = Result->getAs<MemberPointerType>();
4996 if (MPT && PointeeType != MPT->getPointeeType()) {
4997 assert(isa<AdjustedType>(MPT->getPointeeType()));
4998 TLB.push<AdjustedTypeLoc>(MPT->getPointeeType());
4999 }
5000
5001 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result);
5002 NewTL.setSigilLoc(TL.getSigilLoc());
5003 NewTL.setClassTInfo(NewClsTInfo);
5004
5005 return Result;
5006}
5007
5008template<typename Derived>
5009QualType
5010TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
5011 ConstantArrayTypeLoc TL) {
5012 const ConstantArrayType *T = TL.getTypePtr();
5013 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5014 if (ElementType.isNull())
5015 return QualType();
5016
5017 // Prefer the expression from the TypeLoc; the other may have been uniqued.
5018 Expr *OldSize = TL.getSizeExpr();
5019 if (!OldSize)
5020 OldSize = const_cast<Expr*>(T->getSizeExpr());
5021 Expr *NewSize = nullptr;
5022 if (OldSize) {
5023 EnterExpressionEvaluationContext Unevaluated(
5024 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
5025 NewSize = getDerived().TransformExpr(OldSize).template getAs<Expr>();
5026 NewSize = SemaRef.ActOnConstantExpression(NewSize).get();
5027 }
5028
5029 QualType Result = TL.getType();
5030 if (getDerived().AlwaysRebuild() ||
5031 ElementType != T->getElementType() ||
5032 (T->getSizeExpr() && NewSize != OldSize)) {
5033 Result = getDerived().RebuildConstantArrayType(ElementType,
5034 T->getSizeModifier(),
5035 T->getSize(), NewSize,
5036 T->getIndexTypeCVRQualifiers(),
5037 TL.getBracketsRange());
5038 if (Result.isNull())
5039 return QualType();
5040 }
5041
5042 // We might have either a ConstantArrayType or a VariableArrayType now:
5043 // a ConstantArrayType is allowed to have an element type which is a
5044 // VariableArrayType if the type is dependent. Fortunately, all array
5045 // types have the same location layout.
5046 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
5047 NewTL.setLBracketLoc(TL.getLBracketLoc());
5048 NewTL.setRBracketLoc(TL.getRBracketLoc());
5049 NewTL.setSizeExpr(NewSize);
5050
5051 return Result;
5052}
5053
5054template<typename Derived>
5055QualType TreeTransform<Derived>::TransformIncompleteArrayType(
5056 TypeLocBuilder &TLB,
5057 IncompleteArrayTypeLoc TL) {
5058 const IncompleteArrayType *T = TL.getTypePtr();
5059 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5060 if (ElementType.isNull())
5061 return QualType();
5062
5063 QualType Result = TL.getType();
5064 if (getDerived().AlwaysRebuild() ||
5065 ElementType != T->getElementType()) {
5066 Result = getDerived().RebuildIncompleteArrayType(ElementType,
5067 T->getSizeModifier(),
5068 T->getIndexTypeCVRQualifiers(),
5069 TL.getBracketsRange());
5070 if (Result.isNull())
5071 return QualType();
5072 }
5073
5074 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result);
5075 NewTL.setLBracketLoc(TL.getLBracketLoc());
5076 NewTL.setRBracketLoc(TL.getRBracketLoc());
5077 NewTL.setSizeExpr(nullptr);
5078
5079 return Result;
5080}
5081
5082template<typename Derived>
5083QualType
5084TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
5085 VariableArrayTypeLoc TL) {
5086 const VariableArrayType *T = TL.getTypePtr();
5087 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5088 if (ElementType.isNull())
5089 return QualType();
5090
5091 ExprResult SizeResult;
5092 {
5093 EnterExpressionEvaluationContext Context(
5094 SemaRef, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
5095 SizeResult = getDerived().TransformExpr(T->getSizeExpr());
5096 }
5097 if (SizeResult.isInvalid())
5098 return QualType();
5099 SizeResult =
5100 SemaRef.ActOnFinishFullExpr(SizeResult.get(), /*DiscardedValue*/ false);
5101 if (SizeResult.isInvalid())
5102 return QualType();
5103
5104 Expr *Size = SizeResult.get();
5105
5106 QualType Result = TL.getType();
5107 if (getDerived().AlwaysRebuild() ||
5108 ElementType != T->getElementType() ||
5109 Size != T->getSizeExpr()) {
5110 Result = getDerived().RebuildVariableArrayType(ElementType,
5111 T->getSizeModifier(),
5112 Size,
5113 T->getIndexTypeCVRQualifiers(),
5114 TL.getBracketsRange());
5115 if (Result.isNull())
5116 return QualType();
5117 }
5118
5119 // We might have constant size array now, but fortunately it has the same
5120 // location layout.
5121 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
5122 NewTL.setLBracketLoc(TL.getLBracketLoc());
5123 NewTL.setRBracketLoc(TL.getRBracketLoc());
5124 NewTL.setSizeExpr(Size);
5125
5126 return Result;
5127}
5128
5129template<typename Derived>
5130QualType
5131TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
5132 DependentSizedArrayTypeLoc TL) {
5133 const DependentSizedArrayType *T = TL.getTypePtr();
5134 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5135 if (ElementType.isNull())
5136 return QualType();
5137
5138 // Array bounds are constant expressions.
5139 EnterExpressionEvaluationContext Unevaluated(
5140 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
5141
5142 // Prefer the expression from the TypeLoc; the other may have been uniqued.
5143 Expr *origSize = TL.getSizeExpr();
5144 if (!origSize) origSize = T->getSizeExpr();
5145
5146 ExprResult sizeResult
5147 = getDerived().TransformExpr(origSize);
5148 sizeResult = SemaRef.ActOnConstantExpression(sizeResult);
5149 if (sizeResult.isInvalid())
5150 return QualType();
5151
5152 Expr *size = sizeResult.get();
5153
5154 QualType Result = TL.getType();
5155 if (getDerived().AlwaysRebuild() ||
5156 ElementType != T->getElementType() ||
5157 size != origSize) {
5158 Result = getDerived().RebuildDependentSizedArrayType(ElementType,
5159 T->getSizeModifier(),
5160 size,
5161 T->getIndexTypeCVRQualifiers(),
5162 TL.getBracketsRange());
5163 if (Result.isNull())
5164 return QualType();
5165 }
5166
5167 // We might have any sort of array type now, but fortunately they
5168 // all have the same location layout.
5169 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
5170 NewTL.setLBracketLoc(TL.getLBracketLoc());
5171 NewTL.setRBracketLoc(TL.getRBracketLoc());
5172 NewTL.setSizeExpr(size);
5173
5174 return Result;
5175}
5176
5177template <typename Derived>
5178QualType TreeTransform<Derived>::TransformDependentVectorType(
5179 TypeLocBuilder &TLB, DependentVectorTypeLoc TL) {
5180 const DependentVectorType *T = TL.getTypePtr();
5181 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5182 if (ElementType.isNull())
5183 return QualType();
5184
5185 EnterExpressionEvaluationContext Unevaluated(
5186 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
5187
5188 ExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
5189 Size = SemaRef.ActOnConstantExpression(Size);
5190 if (Size.isInvalid())
5191 return QualType();
5192
5193 QualType Result = TL.getType();
5194 if (getDerived().AlwaysRebuild() || ElementType != T->getElementType() ||
5195 Size.get() != T->getSizeExpr()) {
5196 Result = getDerived().RebuildDependentVectorType(
5197 ElementType, Size.get(), T->getAttributeLoc(), T->getVectorKind());
5198 if (Result.isNull())
5199 return QualType();
5200 }
5201
5202 // Result might be dependent or not.
5203 if (isa<DependentVectorType>(Result)) {
5204 DependentVectorTypeLoc NewTL =
5205 TLB.push<DependentVectorTypeLoc>(Result);
5206 NewTL.setNameLoc(TL.getNameLoc());
5207 } else {
5208 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
5209 NewTL.setNameLoc(TL.getNameLoc());
5210 }
5211
5212 return Result;
5213}
5214
5215template<typename Derived>
5216QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(
5217 TypeLocBuilder &TLB,
5218 DependentSizedExtVectorTypeLoc TL) {
5219 const DependentSizedExtVectorType *T = TL.getTypePtr();
5220
5221 // FIXME: ext vector locs should be nested
5222 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5223 if (ElementType.isNull())
5224 return QualType();
5225
5226 // Vector sizes are constant expressions.
5227 EnterExpressionEvaluationContext Unevaluated(
5228 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
5229
5230 ExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
5231 Size = SemaRef.ActOnConstantExpression(Size);
5232 if (Size.isInvalid())
5233 return QualType();
5234
5235 QualType Result = TL.getType();
5236 if (getDerived().AlwaysRebuild() ||
5237 ElementType != T->getElementType() ||
5238 Size.get() != T->getSizeExpr()) {
5239 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType,
5240 Size.get(),
5241 T->getAttributeLoc());
5242 if (Result.isNull())
5243 return QualType();
5244 }
5245
5246 // Result might be dependent or not.
5247 if (isa<DependentSizedExtVectorType>(Result)) {
5248 DependentSizedExtVectorTypeLoc NewTL
5249 = TLB.push<DependentSizedExtVectorTypeLoc>(Result);
5250 NewTL.setNameLoc(TL.getNameLoc());
5251 } else {
5252 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
5253 NewTL.setNameLoc(TL.getNameLoc());
5254 }
5255
5256 return Result;
5257}
5258
5259template <typename Derived>
5260QualType
5261TreeTransform<Derived>::TransformConstantMatrixType(TypeLocBuilder &TLB,
5262 ConstantMatrixTypeLoc TL) {
5263 const ConstantMatrixType *T = TL.getTypePtr();
5264 QualType ElementType = getDerived().TransformType(T->getElementType());
5265 if (ElementType.isNull())
5266 return QualType();
5267
5268 QualType Result = TL.getType();
5269 if (getDerived().AlwaysRebuild() || ElementType != T->getElementType()) {
5270 Result = getDerived().RebuildConstantMatrixType(
5271 ElementType, T->getNumRows(), T->getNumColumns());
5272 if (Result.isNull())
5273 return QualType();
5274 }
5275
5276 ConstantMatrixTypeLoc NewTL = TLB.push<ConstantMatrixTypeLoc>(Result);
5277 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
5278 NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
5279 NewTL.setAttrRowOperand(TL.getAttrRowOperand());
5280 NewTL.setAttrColumnOperand(TL.getAttrColumnOperand());
5281
5282 return Result;
5283}
5284
5285template <typename Derived>
5286QualType TreeTransform<Derived>::TransformDependentSizedMatrixType(
5287 TypeLocBuilder &TLB, DependentSizedMatrixTypeLoc TL) {
5288 const DependentSizedMatrixType *T = TL.getTypePtr();
5289
5290 QualType ElementType = getDerived().TransformType(T->getElementType());
5291 if (ElementType.isNull()) {
5292 return QualType();
5293 }
5294
5295 // Matrix dimensions are constant expressions.
5296 EnterExpressionEvaluationContext Unevaluated(
5297 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
5298
5299 Expr *origRows = TL.getAttrRowOperand();
5300 if (!origRows)
5301 origRows = T->getRowExpr();
5302 Expr *origColumns = TL.getAttrColumnOperand();
5303 if (!origColumns)
5304 origColumns = T->getColumnExpr();
5305
5306 ExprResult rowResult = getDerived().TransformExpr(origRows);
5307 rowResult = SemaRef.ActOnConstantExpression(rowResult);
5308 if (rowResult.isInvalid())
5309 return QualType();
5310
5311 ExprResult columnResult = getDerived().TransformExpr(origColumns);
5312 columnResult = SemaRef.ActOnConstantExpression(columnResult);
5313 if (columnResult.isInvalid())
5314 return QualType();
5315
5316 Expr *rows = rowResult.get();
5317 Expr *columns = columnResult.get();
5318
5319 QualType Result = TL.getType();
5320 if (getDerived().AlwaysRebuild() || ElementType != T->getElementType() ||
5321 rows != origRows || columns != origColumns) {
5322 Result = getDerived().RebuildDependentSizedMatrixType(
5323 ElementType, rows, columns, T->getAttributeLoc());
5324
5325 if (Result.isNull())
5326 return QualType();
5327 }
5328
5329 // We might have any sort of matrix type now, but fortunately they
5330 // all have the same location layout.
5331 MatrixTypeLoc NewTL = TLB.push<MatrixTypeLoc>(Result);
5332 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
5333 NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
5334 NewTL.setAttrRowOperand(rows);
5335 NewTL.setAttrColumnOperand(columns);
5336 return Result;
5337}
5338
5339template <typename Derived>
5340QualType TreeTransform<Derived>::TransformDependentAddressSpaceType(
5341 TypeLocBuilder &TLB, DependentAddressSpaceTypeLoc TL) {
5342 const DependentAddressSpaceType *T = TL.getTypePtr();
5343
5344 QualType pointeeType = getDerived().TransformType(T->getPointeeType());
5345
5346 if (pointeeType.isNull())
5347 return QualType();
5348
5349 // Address spaces are constant expressions.
5350 EnterExpressionEvaluationContext Unevaluated(
5351 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
5352
5353 ExprResult AddrSpace = getDerived().TransformExpr(T->getAddrSpaceExpr());
5354 AddrSpace = SemaRef.ActOnConstantExpression(AddrSpace);
5355 if (AddrSpace.isInvalid())
5356 return QualType();
5357
5358 QualType Result = TL.getType();
5359 if (getDerived().AlwaysRebuild() || pointeeType != T->getPointeeType() ||
5360 AddrSpace.get() != T->getAddrSpaceExpr()) {
5361 Result = getDerived().RebuildDependentAddressSpaceType(
5362 pointeeType, AddrSpace.get(), T->getAttributeLoc());
5363 if (Result.isNull())
5364 return QualType();
5365 }
5366
5367 // Result might be dependent or not.
5368 if (isa<DependentAddressSpaceType>(Result)) {
5369 DependentAddressSpaceTypeLoc NewTL =
5370 TLB.push<DependentAddressSpaceTypeLoc>(Result);
5371
5372 NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
5373 NewTL.setAttrExprOperand(TL.getAttrExprOperand());
5374 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
5375
5376 } else {
5377 TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(
5378 Result, getDerived().getBaseLocation());
5379 TransformType(TLB, DI->getTypeLoc());
5380 }
5381
5382 return Result;
5383}
5384
5385template <typename Derived>
5386QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
5387 VectorTypeLoc TL) {
5388 const VectorType *T = TL.getTypePtr();
5389 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5390 if (ElementType.isNull())
5391 return QualType();
5392
5393 QualType Result = TL.getType();
5394 if (getDerived().AlwaysRebuild() ||
5395 ElementType != T->getElementType()) {
5396 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(),
5397 T->getVectorKind());
5398 if (Result.isNull())
5399 return QualType();
5400 }
5401
5402 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
5403 NewTL.setNameLoc(TL.getNameLoc());
5404
5405 return Result;
5406}
5407
5408template<typename Derived>
5409QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
5410 ExtVectorTypeLoc TL) {
5411 const VectorType *T = TL.getTypePtr();
5412 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5413 if (ElementType.isNull())
5414 return QualType();
5415
5416 QualType Result = TL.getType();
5417 if (getDerived().AlwaysRebuild() ||
5418 ElementType != T->getElementType()) {
5419 Result = getDerived().RebuildExtVectorType(ElementType,
5420 T->getNumElements(),
5421 /*FIXME*/ SourceLocation());
5422 if (Result.isNull())
5423 return QualType();
5424 }
5425
5426 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
5427 NewTL.setNameLoc(TL.getNameLoc());
5428
5429 return Result;
5430}
5431
5432template <typename Derived>
5433ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam(
5434 ParmVarDecl *OldParm, int indexAdjustment, Optional<unsigned> NumExpansions,
5435 bool ExpectParameterPack) {
5436 TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
5437 TypeSourceInfo *NewDI = nullptr;
5438
5439 if (NumExpansions && isa<PackExpansionType>(OldDI->getType())) {
5440 // If we're substituting into a pack expansion type and we know the
5441 // length we want to expand to, just substitute for the pattern.
5442 TypeLoc OldTL = OldDI->getTypeLoc();
5443 PackExpansionTypeLoc OldExpansionTL = OldTL.castAs<PackExpansionTypeLoc>();
5444
5445 TypeLocBuilder TLB;
5446 TypeLoc NewTL = OldDI->getTypeLoc();
5447 TLB.reserve(NewTL.getFullDataSize());
5448
5449 QualType Result = getDerived().TransformType(TLB,
5450 OldExpansionTL.getPatternLoc());
5451 if (Result.isNull())
5452 return nullptr;
5453
5454 Result = RebuildPackExpansionType(Result,
5455 OldExpansionTL.getPatternLoc().getSourceRange(),
5456 OldExpansionTL.getEllipsisLoc(),
5457 NumExpansions);
5458 if (Result.isNull())
5459 return nullptr;
5460
5461 PackExpansionTypeLoc NewExpansionTL
5462 = TLB.push<PackExpansionTypeLoc>(Result);
5463 NewExpansionTL.setEllipsisLoc(OldExpansionTL.getEllipsisLoc());
5464 NewDI = TLB.getTypeSourceInfo(SemaRef.Context, Result);
5465 } else
5466 NewDI = getDerived().TransformType(OldDI);
5467 if (!NewDI)
5468 return nullptr;
5469
5470 if (NewDI == OldDI && indexAdjustment == 0)
5471 return OldParm;
5472
5473 ParmVarDecl *newParm = ParmVarDecl::Create(SemaRef.Context,
5474 OldParm->getDeclContext(),
5475 OldParm->getInnerLocStart(),
5476 OldParm->getLocation(),
5477 OldParm->getIdentifier(),
5478 NewDI->getType(),
5479 NewDI,
5480 OldParm->getStorageClass(),
5481 /* DefArg */ nullptr);
5482 newParm->setScopeInfo(OldParm->getFunctionScopeDepth(),
5483 OldParm->getFunctionScopeIndex() + indexAdjustment);
5484 transformedLocalDecl(OldParm, {newParm});
5485 return newParm;
5486}
5487
5488template <typename Derived>
5489bool TreeTransform<Derived>::TransformFunctionTypeParams(
5490 SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
5491 const QualType *ParamTypes,
5492 const FunctionProtoType::ExtParameterInfo *ParamInfos,
5493 SmallVectorImpl<QualType> &OutParamTypes,
5494 SmallVectorImpl<ParmVarDecl *> *PVars,
5495 Sema::ExtParameterInfoBuilder &PInfos) {
5496 int indexAdjustment = 0;
5497
5498 unsigned NumParams = Params.size();
5499 for (unsigned i = 0; i != NumParams; ++i) {
5500 if (ParmVarDecl *OldParm = Params[i]) {
5501 assert(OldParm->getFunctionScopeIndex() == i);
5502
5503 Optional<unsigned> NumExpansions;
5504 ParmVarDecl *NewParm = nullptr;
5505 if (OldParm->isParameterPack()) {
5506 // We have a function parameter pack that may need to be expanded.
5507 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
5508
5509 // Find the parameter packs that could be expanded.
5510 TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc();
5511 PackExpansionTypeLoc ExpansionTL = TL.castAs<PackExpansionTypeLoc>();
5512 TypeLoc Pattern = ExpansionTL.getPatternLoc();
5513 SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
5514
5515 // Determine whether we should expand the parameter packs.
5516 bool ShouldExpand = false;
5517 bool RetainExpansion = false;
5518 Optional<unsigned> OrigNumExpansions;
5519 if (Unexpanded.size() > 0) {
5520 OrigNumExpansions = ExpansionTL.getTypePtr()->getNumExpansions();
5521 NumExpansions = OrigNumExpansions;
5522 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
5523 Pattern.getSourceRange(),
5524 Unexpanded,
5525 ShouldExpand,
5526 RetainExpansion,
5527 NumExpansions)) {
5528 return true;
5529 }
5530 } else {
5531#ifndef NDEBUG
5532 const AutoType *AT =
5533 Pattern.getType().getTypePtr()->getContainedAutoType();
5534 assert((AT && (!AT->isDeduced() || AT->getDeducedType().isNull())) &&
5535 "Could not find parameter packs or undeduced auto type!");
5536#endif
5537 }
5538
5539 if (ShouldExpand) {
5540 // Expand the function parameter pack into multiple, separate
5541 // parameters.
5542 getDerived().ExpandingFunctionParameterPack(OldParm);
5543 for (unsigned I = 0; I != *NumExpansions; ++I) {
5544 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
5545 ParmVarDecl *NewParm
5546 = getDerived().TransformFunctionTypeParam(OldParm,
5547 indexAdjustment++,
5548 OrigNumExpansions,
5549 /*ExpectParameterPack=*/false);
5550 if (!NewParm)
5551 return true;
5552
5553 if (ParamInfos)
5554 PInfos.set(OutParamTypes.size(), ParamInfos[i]);
5555 OutParamTypes.push_back(NewParm->getType());
5556 if (PVars)
5557 PVars->push_back(NewParm);
5558 }
5559
5560 // If we're supposed to retain a pack expansion, do so by temporarily
5561 // forgetting the partially-substituted parameter pack.
5562 if (RetainExpansion) {
5563 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
5564 ParmVarDecl *NewParm
5565 = getDerived().TransformFunctionTypeParam(OldParm,
5566 indexAdjustment++,
5567 OrigNumExpansions,
5568 /*ExpectParameterPack=*/false);
5569 if (!NewParm)
5570 return true;
5571
5572 if (ParamInfos)
5573 PInfos.set(OutParamTypes.size(), ParamInfos[i]);
5574 OutParamTypes.push_back(NewParm->getType());
5575 if (PVars)
5576 PVars->push_back(NewParm);
5577 }
5578
5579 // The next parameter should have the same adjustment as the
5580 // last thing we pushed, but we post-incremented indexAdjustment
5581 // on every push. Also, if we push nothing, the adjustment should
5582 // go down by one.
5583 indexAdjustment--;
5584
5585 // We're done with the pack expansion.
5586 continue;
5587 }
5588
5589 // We'll substitute the parameter now without expanding the pack
5590 // expansion.
5591 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
5592 NewParm = getDerived().TransformFunctionTypeParam(OldParm,
5593 indexAdjustment,
5594 NumExpansions,
5595 /*ExpectParameterPack=*/true);
5596 assert(NewParm->isParameterPack() &&
5597 "Parameter pack no longer a parameter pack after "
5598 "transformation.");
5599 } else {
5600 NewParm = getDerived().TransformFunctionTypeParam(
5601 OldParm, indexAdjustment, None, /*ExpectParameterPack=*/ false);
5602 }
5603
5604 if (!NewParm)
5605 return true;
5606
5607 if (ParamInfos)
5608 PInfos.set(OutParamTypes.size(), ParamInfos[i]);
5609 OutParamTypes.push_back(NewParm->getType());
5610 if (PVars)
5611 PVars->push_back(NewParm);
5612 continue;
5613 }
5614
5615 // Deal with the possibility that we don't have a parameter
5616 // declaration for this parameter.
5617 QualType OldType = ParamTypes[i];
5618 bool IsPackExpansion = false;
5619 Optional<unsigned> NumExpansions;
5620 QualType NewType;
5621 if (const PackExpansionType *Expansion
5622 = dyn_cast<PackExpansionType>(OldType)) {
5623 // We have a function parameter pack that may need to be expanded.
5624 QualType Pattern = Expansion->getPattern();
5625 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
5626 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
5627
5628 // Determine whether we should expand the parameter packs.
5629 bool ShouldExpand = false;
5630 bool RetainExpansion = false;
5631 if (getDerived().TryExpandParameterPacks(Loc, SourceRange(),
5632 Unexpanded,
5633 ShouldExpand,
5634 RetainExpansion,
5635 NumExpansions)) {
5636 return true;
5637 }
5638
5639 if (ShouldExpand) {
5640 // Expand the function parameter pack into multiple, separate
5641 // parameters.
5642 for (unsigned I = 0; I != *NumExpansions; ++I) {
5643 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
5644 QualType NewType = getDerived().TransformType(Pattern);
5645 if (NewType.isNull())
5646 return true;
5647
5648 if (NewType->containsUnexpandedParameterPack()) {
5649 NewType =
5650 getSema().getASTContext().getPackExpansionType(NewType, None);
5651
5652 if (NewType.isNull())
5653 return true;
5654 }
5655
5656 if (ParamInfos)
5657 PInfos.set(OutParamTypes.size(), ParamInfos[i]);
5658 OutParamTypes.push_back(NewType);
5659 if (PVars)
5660 PVars->push_back(nullptr);
5661 }
5662
5663 // We're done with the pack expansion.
5664 continue;
5665 }
5666
5667 // If we're supposed to retain a pack expansion, do so by temporarily
5668 // forgetting the partially-substituted parameter pack.
5669 if (RetainExpansion) {
5670 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
5671 QualType NewType = getDerived().TransformType(Pattern);
5672 if (NewType.isNull())
5673 return true;
5674
5675 if (ParamInfos)
5676 PInfos.set(OutParamTypes.size(), ParamInfos[i]);
5677 OutParamTypes.push_back(NewType);
5678 if (PVars)
5679 PVars->push_back(nullptr);
5680 }
5681
5682 // We'll substitute the parameter now without expanding the pack
5683 // expansion.
5684 OldType = Expansion->getPattern();
5685 IsPackExpansion = true;
5686 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
5687 NewType = getDerived().TransformType(OldType);
5688 } else {
5689 NewType = getDerived().TransformType(OldType);
5690 }
5691
5692 if (NewType.isNull())
5693 return true;
5694
5695 if (IsPackExpansion)
5696 NewType = getSema().Context.getPackExpansionType(NewType,
5697 NumExpansions);
5698
5699 if (ParamInfos)
5700 PInfos.set(OutParamTypes.size(), ParamInfos[i]);
5701 OutParamTypes.push_back(NewType);
5702 if (PVars)
5703 PVars->push_back(nullptr);
5704 }
5705
5706#ifndef NDEBUG
5707 if (PVars) {
5708 for (unsigned i = 0, e = PVars->size(); i != e; ++i)
5709 if (ParmVarDecl *parm = (*PVars)[i])
5710 assert(parm->getFunctionScopeIndex() == i);
5711 }
5712#endif
5713
5714 return false;
5715}
5716
5717template<typename Derived>
5718QualType
5719TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB,
5720 FunctionProtoTypeLoc TL) {
5721 SmallVector<QualType, 4> ExceptionStorage;
5722 TreeTransform *This = this; // Work around gcc.gnu.org/PR56135.
5723 return getDerived().TransformFunctionProtoType(
5724 TLB, TL, nullptr, Qualifiers(),
5725 [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) {
5726 return This->TransformExceptionSpec(TL.getBeginLoc(), ESI,
5727 ExceptionStorage, Changed);
5728 });
5729}
5730
5731template<typename Derived> template<typename Fn>
5732QualType TreeTransform<Derived>::TransformFunctionProtoType(
5733 TypeLocBuilder &TLB, FunctionProtoTypeLoc TL, CXXRecordDecl *ThisContext,
5734 Qualifiers ThisTypeQuals, Fn TransformExceptionSpec) {
5735
5736 // Transform the parameters and return type.
5737 //
5738 // We are required to instantiate the params and return type in source order.
5739 // When the function has a trailing return type, we instantiate the
5740 // parameters before the return type, since the return type can then refer
5741 // to the parameters themselves (via decltype, sizeof, etc.).
5742 //
5743 SmallVector<QualType, 4> ParamTypes;
5744 SmallVector<ParmVarDecl*, 4> ParamDecls;
5745 Sema::ExtParameterInfoBuilder ExtParamInfos;
5746 const FunctionProtoType *T = TL.getTypePtr();
5747
5748 QualType ResultType;
5749
5750 if (T->hasTrailingReturn()) {
5751 if (getDerived().TransformFunctionTypeParams(
5752 TL.getBeginLoc(), TL.getParams(),
5753 TL.getTypePtr()->param_type_begin(),
5754 T->getExtParameterInfosOrNull(),
5755 ParamTypes, &ParamDecls, ExtParamInfos))
5756 return QualType();
5757
5758 {
5759 // C++11 [expr.prim.general]p3:
5760 // If a declaration declares a member function or member function
5761 // template of a class X, the expression this is a prvalue of type
5762 // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
5763 // and the end of the function-definition, member-declarator, or
5764 // declarator.
5765 Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, ThisTypeQuals);
5766
5767 ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
5768 if (ResultType.isNull())
5769 return QualType();
5770 }
5771 }
5772 else {
5773 ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
5774 if (ResultType.isNull())
5775 return QualType();
5776
5777 if (getDerived().TransformFunctionTypeParams(
5778 TL.getBeginLoc(), TL.getParams(),
5779 TL.getTypePtr()->param_type_begin(),
5780 T->getExtParameterInfosOrNull(),
5781 ParamTypes, &ParamDecls, ExtParamInfos))
5782 return QualType();
5783 }
5784
5785 FunctionProtoType::ExtProtoInfo EPI = T->getExtProtoInfo();
5786
5787 bool EPIChanged = false;
5788 if (TransformExceptionSpec(EPI.ExceptionSpec, EPIChanged))
5789 return QualType();
5790
5791 // Handle extended parameter information.
5792 if (auto NewExtParamInfos =
5793 ExtParamInfos.getPointerOrNull(ParamTypes.size())) {
5794 if (!EPI.ExtParameterInfos ||
5795 llvm::makeArrayRef(EPI.ExtParameterInfos, TL.getNumParams())
5796 != llvm::makeArrayRef(NewExtParamInfos, ParamTypes.size())) {
5797 EPIChanged = true;
5798 }
5799 EPI.ExtParameterInfos = NewExtParamInfos;
5800 } else if (EPI.ExtParameterInfos) {
5801 EPIChanged = true;
5802 EPI.ExtParameterInfos = nullptr;
5803 }
5804
5805 QualType Result = TL.getType();
5806 if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType() ||
5807 T->getParamTypes() != llvm::makeArrayRef(ParamTypes) || EPIChanged) {
5808 Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI);
5809 if (Result.isNull())
5810 return QualType();
5811 }
5812
5813 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result);
5814 NewTL.setLocalRangeBegin(TL.getLocalRangeBegin());
5815 NewTL.setLParenLoc(TL.getLParenLoc());
5816 NewTL.setRParenLoc(TL.getRParenLoc());
5817 NewTL.setExceptionSpecRange(TL.getExceptionSpecRange());
5818 NewTL.setLocalRangeEnd(TL.getLocalRangeEnd());
5819 for (unsigned i = 0, e = NewTL.getNumParams(); i != e; ++i)
5820 NewTL.setParam(i, ParamDecls[i]);
5821
5822 return Result;
5823}
5824
5825template<typename Derived>
5826bool TreeTransform<Derived>::TransformExceptionSpec(
5827 SourceLocation Loc, FunctionProtoType::ExceptionSpecInfo &ESI,
5828 SmallVectorImpl<QualType> &Exceptions, bool &Changed) {
5829 assert(ESI.Type != EST_Uninstantiated && ESI.Type != EST_Unevaluated);
5830
5831 // Instantiate a dynamic noexcept expression, if any.
5832 if (isComputedNoexcept(ESI.Type)) {
5833 EnterExpressionEvaluationContext Unevaluated(
5834 getSema(), Sema::ExpressionEvaluationContext::ConstantEvaluated);
5835 ExprResult NoexceptExpr = getDerived().TransformExpr(ESI.NoexceptExpr);
5836 if (NoexceptExpr.isInvalid())
5837 return true;
5838
5839 ExceptionSpecificationType EST = ESI.Type;
5840 NoexceptExpr =
5841 getSema().ActOnNoexceptSpec(Loc, NoexceptExpr.get(), EST);
5842 if (NoexceptExpr.isInvalid())
5843 return true;
5844
5845 if (ESI.NoexceptExpr != NoexceptExpr.get() || EST != ESI.Type)
5846 Changed = true;
5847 ESI.NoexceptExpr = NoexceptExpr.get();
5848 ESI.Type = EST;
5849 }
5850
5851 if (ESI.Type != EST_Dynamic)
5852 return false;
5853
5854 // Instantiate a dynamic exception specification's type.
5855 for (QualType T : ESI.Exceptions) {
5856 if (const PackExpansionType *PackExpansion =
5857 T->getAs<PackExpansionType>()) {
5858 Changed = true;
5859
5860 // We have a pack expansion. Instantiate it.
5861 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
5862 SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
5863 Unexpanded);
5864 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
5865
5866 // Determine whether the set of unexpanded parameter packs can and
5867 // should
5868 // be expanded.
5869 bool Expand = false;
5870 bool RetainExpansion = false;
5871 Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
5872 // FIXME: Track the location of the ellipsis (and track source location
5873 // information for the types in the exception specification in general).
5874 if (getDerived().TryExpandParameterPacks(
5875 Loc, SourceRange(), Unexpanded, Expand,
5876 RetainExpansion, NumExpansions))
5877 return true;
5878
5879 if (!Expand) {
5880 // We can't expand this pack expansion into separate arguments yet;
5881 // just substitute into the pattern and create a new pack expansion
5882 // type.
5883 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
5884 QualType U = getDerived().TransformType(PackExpansion->getPattern());
5885 if (U.isNull())
5886 return true;
5887
5888 U = SemaRef.Context.getPackExpansionType(U, NumExpansions);
5889 Exceptions.push_back(U);
5890 continue;
5891 }
5892
5893 // Substitute into the pack expansion pattern for each slice of the
5894 // pack.
5895 for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
5896 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);
5897
5898 QualType U = getDerived().TransformType(PackExpansion->getPattern());
5899 if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
5900 return true;
5901
5902 Exceptions.push_back(U);
5903 }
5904 } else {
5905 QualType U = getDerived().TransformType(T);
5906 if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc))
5907 return true;
5908 if (T != U)
5909 Changed = true;
5910
5911 Exceptions.push_back(U);
5912 }
5913 }
5914
5915 ESI.Exceptions = Exceptions;
5916 if (ESI.Exceptions.empty())
5917 ESI.Type = EST_DynamicNone;
5918 return false;
5919}
5920
5921template<typename Derived>
5922QualType TreeTransform<Derived>::TransformFunctionNoProtoType(
5923 TypeLocBuilder &TLB,
5924 FunctionNoProtoTypeLoc TL) {
5925 const FunctionNoProtoType *T = TL.getTypePtr();
5926 QualType ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
5927 if (ResultType.isNull())
5928 return QualType();
5929
5930 QualType Result = TL.getType();
5931 if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType())
5932 Result = getDerived().RebuildFunctionNoProtoType(ResultType);
5933
5934 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result);
5935 NewTL.setLocalRangeBegin(TL.getLocalRangeBegin());
5936 NewTL.setLParenLoc(TL.getLParenLoc());
5937 NewTL.setRParenLoc(TL.getRParenLoc());
5938 NewTL.setLocalRangeEnd(TL.getLocalRangeEnd());
5939
5940 return Result;
5941}
5942
5943template<typename Derived> QualType
5944TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB,
5945 UnresolvedUsingTypeLoc TL) {
5946 const UnresolvedUsingType *T = TL.getTypePtr();
5947 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl());
5948 if (!D)
5949 return QualType();
5950
5951 QualType Result = TL.getType();
5952 if (getDerived().AlwaysRebuild() || D != T->getDecl()) {
5953 Result = getDerived().RebuildUnresolvedUsingType(TL.getNameLoc(), D);
5954 if (Result.isNull())
5955 return QualType();
5956 }
5957
5958 // We might get an arbitrary type spec type back. We should at
5959 // least always get a type spec type, though.
5960 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result);
5961 NewTL.setNameLoc(TL.getNameLoc());
5962
5963 return Result;
5964}
5965
5966template<typename Derived>
5967QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,
5968 TypedefTypeLoc TL) {
5969 const TypedefType *T = TL.getTypePtr();
5970 TypedefNameDecl *Typedef
5971 = cast_or_null<TypedefNameDecl>(getDerived().TransformDecl(TL.getNameLoc(),
5972 T->getDecl()));
5973 if (!Typedef)
5974 return QualType();
5975
5976 QualType Result = TL.getType();
5977 if (getDerived().AlwaysRebuild() ||
5978 Typedef != T->getDecl()) {
5979 Result = getDerived().RebuildTypedefType(Typedef);
5980 if (Result.isNull())
5981 return QualType();
5982 }
5983
5984 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result);
5985 NewTL.setNameLoc(TL.getNameLoc());
5986
5987 return Result;
5988}
5989
5990template<typename Derived>
5991QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,
5992 TypeOfExprTypeLoc TL) {
5993 // typeof expressions are not potentially evaluated contexts
5994 EnterExpressionEvaluationContext Unevaluated(
5995 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated,
5996 Sema::ReuseLambdaContextDecl);
5997
5998 ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr());
5999 if (E.isInvalid())
6000 return QualType();
6001
6002 E = SemaRef.HandleExprEvaluationContextForTypeof(E.get());
6003 if (E.isInvalid())
6004 return QualType();
6005
6006 QualType Result = TL.getType();
6007 if (getDerived().AlwaysRebuild() ||
6008 E.get() != TL.getUnderlyingExpr()) {
6009 Result = getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc());
6010 if (Result.isNull())
6011 return QualType();
6012 }
6013 else E.get();
6014
6015 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result);
6016 NewTL.setTypeofLoc(TL.getTypeofLoc());
6017 NewTL.setLParenLoc(TL.getLParenLoc());
6018 NewTL.setRParenLoc(TL.getRParenLoc());
6019
6020 return Result;
6021}
6022
6023template<typename Derived>
6024QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,
6025 TypeOfTypeLoc TL) {
6026 TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo();
6027 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI);
6028 if (!New_Under_TI)
6029 return QualType();
6030
6031 QualType Result = TL.getType();
6032 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) {
6033 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType());
6034 if (Result.isNull())
6035 return QualType();
6036 }
6037
6038 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result);
6039 NewTL.setTypeofLoc(TL.getTypeofLoc());
6040 NewTL.setLParenLoc(TL.getLParenLoc());
6041 NewTL.setRParenLoc(TL.getRParenLoc());
6042 NewTL.setUnderlyingTInfo(New_Under_TI);
6043
6044 return Result;
6045}
6046
6047template<typename Derived>
6048QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
6049 DecltypeTypeLoc TL) {
6050 const DecltypeType *T = TL.getTypePtr();
6051
6052 // decltype expressions are not potentially evaluated contexts
6053 EnterExpressionEvaluationContext Unevaluated(
6054 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated, nullptr,
6055 Sema::ExpressionEvaluationContextRecord::EK_Decltype);
6056
6057 ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr());
6058 if (E.isInvalid())
6059 return QualType();
6060
6061 E = getSema().ActOnDecltypeExpression(E.get());
6062 if (E.isInvalid())
6063 return QualType();
6064
6065 QualType Result = TL.getType();
6066 if (getDerived().AlwaysRebuild() ||
6067 E.get() != T->getUnderlyingExpr()) {
6068 Result = getDerived().RebuildDecltypeType(E.get(), TL.getNameLoc());
6069 if (Result.isNull())
6070 return QualType();
6071 }
6072 else E.get();
6073
6074 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result);
6075 NewTL.setNameLoc(TL.getNameLoc());
6076
6077 return Result;
6078}
6079
6080template<typename Derived>
6081QualType TreeTransform<Derived>::TransformUnaryTransformType(
6082 TypeLocBuilder &TLB,
6083 UnaryTransformTypeLoc TL) {
6084 QualType Result = TL.getType();
6085 if (Result->isDependentType()) {
6086 const UnaryTransformType *T = TL.getTypePtr();
6087 QualType NewBase =
6088 getDerived().TransformType(TL.getUnderlyingTInfo())->getType();
6089 Result = getDerived().RebuildUnaryTransformType(NewBase,
6090 T->getUTTKind(),
6091 TL.getKWLoc());
6092 if (Result.isNull())
6093 return QualType();
6094 }
6095
6096 UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result);
6097 NewTL.setKWLoc(TL.getKWLoc());
6098 NewTL.setParensRange(TL.getParensRange());
6099 NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo());
6100 return Result;
6101}
6102
6103template<typename Derived>
6104QualType TreeTransform<Derived>::TransformDeducedTemplateSpecializationType(
6105 TypeLocBuilder &TLB, DeducedTemplateSpecializationTypeLoc TL) {
6106 const DeducedTemplateSpecializationType *T = TL.getTypePtr();
6107
6108 CXXScopeSpec SS;
6109 TemplateName TemplateName = getDerived().TransformTemplateName(
6110 SS, T->getTemplateName(), TL.getTemplateNameLoc());
6111 if (TemplateName.isNull())
6112 return QualType();
6113
6114 QualType OldDeduced = T->getDeducedType();
6115 QualType NewDeduced;
6116 if (!OldDeduced.isNull()) {
6117 NewDeduced = getDerived().TransformType(OldDeduced);
6118 if (NewDeduced.isNull())
6119 return QualType();
6120 }
6121
6122 QualType Result = getDerived().RebuildDeducedTemplateSpecializationType(
6123 TemplateName, NewDeduced);
6124 if (Result.isNull())
6125 return QualType();
6126
6127 DeducedTemplateSpecializationTypeLoc NewTL =
6128 TLB.push<DeducedTemplateSpecializationTypeLoc>(Result);
6129 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
6130
6131 return Result;
6132}
6133
6134template<typename Derived>
6135QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB,
6136 RecordTypeLoc TL) {
6137 const RecordType *T = TL.getTypePtr();
6138 RecordDecl *Record
6139 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(),
6140 T->getDecl()));
6141 if (!Record)
6142 return QualType();
6143
6144 QualType Result = TL.getType();
6145 if (getDerived().AlwaysRebuild() ||
6146 Record != T->getDecl()) {
6147 Result = getDerived().RebuildRecordType(Record);
6148 if (Result.isNull())
6149 return QualType();
6150 }
6151
6152 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result);
6153 NewTL.setNameLoc(TL.getNameLoc());
6154
6155 return Result;
6156}
6157
6158template<typename Derived>
6159QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,
6160 EnumTypeLoc TL) {
6161 const EnumType *T = TL.getTypePtr();
6162 EnumDecl *Enum
6163 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(),
6164 T->getDecl()));
6165 if (!Enum)
6166 return QualType();
6167
6168 QualType Result = TL.getType();
6169 if (getDerived().AlwaysRebuild() ||
6170 Enum != T->getDecl()) {
6171 Result = getDerived().RebuildEnumType(Enum);
6172 if (Result.isNull())
6173 return QualType();
6174 }
6175
6176 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result);
6177 NewTL.setNameLoc(TL.getNameLoc());
6178
6179 return Result;
6180}
6181
6182template<typename Derived>
6183QualType TreeTransform<Derived>::TransformInjectedClassNameType(
6184 TypeLocBuilder &TLB,
6185 InjectedClassNameTypeLoc TL) {
6186 Decl *D = getDerived().TransformDecl(TL.getNameLoc(),
6187 TL.getTypePtr()->getDecl());
6188 if (!D) return QualType();
6189
6190 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D));
6191 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc());
6192 return T;
6193}
6194
6195template<typename Derived>
6196QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
6197 TypeLocBuilder &TLB,
6198 TemplateTypeParmTypeLoc TL) {
6199 return TransformTypeSpecType(TLB, TL);
6200}
6201
6202template<typename Derived>
6203QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
6204 TypeLocBuilder &TLB,
6205 SubstTemplateTypeParmTypeLoc TL) {
6206 const SubstTemplateTypeParmType *T = TL.getTypePtr();
6207
6208 // Substitute into the replacement type, which itself might involve something
6209 // that needs to be transformed. This only tends to occur with default
6210 // template arguments of template template parameters.
6211 TemporaryBase Rebase(*this, TL.getNameLoc(), DeclarationName());
6212 QualType Replacement = getDerived().TransformType(T->getReplacementType());
6213 if (Replacement.isNull())
6214 return QualType();
6215
6216 // Always canonicalize the replacement type.
6217 Replacement = SemaRef.Context.getCanonicalType(Replacement);
6218 QualType Result
6219 = SemaRef.Context.getSubstTemplateTypeParmType(T->getReplacedParameter(),
6220 Replacement);
6221
6222 // Propagate type-source information.
6223 SubstTemplateTypeParmTypeLoc NewTL
6224 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
6225 NewTL.setNameLoc(TL.getNameLoc());
6226 return Result;
6227
6228}
6229
6230template<typename Derived>
6231QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType(
6232 TypeLocBuilder &TLB,
6233 SubstTemplateTypeParmPackTypeLoc TL) {
6234 return TransformTypeSpecType(TLB, TL);
6235}
6236
6237template<typename Derived>
6238QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
6239 TypeLocBuilder &TLB,
6240 TemplateSpecializationTypeLoc TL) {
6241 const TemplateSpecializationType *T = TL.getTypePtr();
6242
6243 // The nested-name-specifier never matters in a TemplateSpecializationType,
6244 // because we can't have a dependent nested-name-specifier anyway.
6245 CXXScopeSpec SS;
6246 TemplateName Template
6247 = getDerived().TransformTemplateName(SS, T->getTemplateName(),
6248 TL.getTemplateNameLoc());
6249 if (Template.isNull())
6250 return QualType();
6251
6252 return getDerived().TransformTemplateSpecializationType(TLB, TL, Template);
6253}
6254
6255template<typename Derived>
6256QualType TreeTransform<Derived>::TransformAtomicType(TypeLocBuilder &TLB,
6257 AtomicTypeLoc TL) {
6258 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
6259 if (ValueType.isNull())
6260 return QualType();
6261
6262 QualType Result = TL.getType();
6263 if (getDerived().AlwaysRebuild() ||
6264 ValueType != TL.getValueLoc().getType()) {
6265 Result = getDerived().RebuildAtomicType(ValueType, TL.getKWLoc());
6266 if (Result.isNull())
6267 return QualType();
6268 }
6269
6270 AtomicTypeLoc NewTL = TLB.push<AtomicTypeLoc>(Result);
6271 NewTL.setKWLoc(TL.getKWLoc());
6272 NewTL.setLParenLoc(TL.getLParenLoc());
6273 NewTL.setRParenLoc(TL.getRParenLoc());
6274
6275 return Result;
6276}
6277
6278template <typename Derived>
6279QualType TreeTransform<Derived>::TransformPipeType(TypeLocBuilder &TLB,
6280 PipeTypeLoc TL) {
6281 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
6282 if (ValueType.isNull())
6283 return QualType();
6284
6285 QualType Result = TL.getType();
6286 if (getDerived().AlwaysRebuild() || ValueType != TL.getValueLoc().getType()) {
6287 const PipeType *PT = Result->castAs<PipeType>();
6288 bool isReadPipe = PT->isReadOnly();
6289 Result = getDerived().RebuildPipeType(ValueType, TL.getKWLoc(), isReadPipe);
6290 if (Result.isNull())
6291 return QualType();
6292 }
6293
6294 PipeTypeLoc NewTL = TLB.push<PipeTypeLoc>(Result);
6295 NewTL.setKWLoc(TL.getKWLoc());
6296
6297 return Result;
6298}
6299
6300template <typename Derived>
6301QualType TreeTransform<Derived>::TransformExtIntType(TypeLocBuilder &TLB,
6302 ExtIntTypeLoc TL) {
6303 const ExtIntType *EIT = TL.getTypePtr();
6304 QualType Result = TL.getType();
6305
6306 if (getDerived().AlwaysRebuild()) {
6307 Result = getDerived().RebuildExtIntType(EIT->isUnsigned(),
6308 EIT->getNumBits(), TL.getNameLoc());
6309 if (Result.isNull())
6310 return QualType();
6311 }
6312
6313 ExtIntTypeLoc NewTL = TLB.push<ExtIntTypeLoc>(Result);
6314 NewTL.setNameLoc(TL.getNameLoc());
6315 return Result;
6316}
6317
6318template <typename Derived>
6319QualType TreeTransform<Derived>::TransformDependentExtIntType(
6320 TypeLocBuilder &TLB, DependentExtIntTypeLoc TL) {
6321 const DependentExtIntType *EIT = TL.getTypePtr();
6322
6323 EnterExpressionEvaluationContext Unevaluated(
6324 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
6325 ExprResult BitsExpr = getDerived().TransformExpr(EIT->getNumBitsExpr());
6326 BitsExpr = SemaRef.ActOnConstantExpression(BitsExpr);
6327
6328 if (BitsExpr.isInvalid())
6329 return QualType();
6330
6331 QualType Result = TL.getType();
6332
6333 if (getDerived().AlwaysRebuild() || BitsExpr.get() != EIT->getNumBitsExpr()) {
6334 Result = getDerived().RebuildDependentExtIntType(
6335 EIT->isUnsigned(), BitsExpr.get(), TL.getNameLoc());
6336
6337 if (Result.isNull())
6338 return QualType();
6339 }
6340
6341 if (isa<DependentExtIntType>(Result)) {
6342 DependentExtIntTypeLoc NewTL = TLB.push<DependentExtIntTypeLoc>(Result);
6343 NewTL.setNameLoc(TL.getNameLoc());
6344 } else {
6345 ExtIntTypeLoc NewTL = TLB.push<ExtIntTypeLoc>(Result);
6346 NewTL.setNameLoc(TL.getNameLoc());
6347 }
6348 return Result;
6349}
6350
6351 /// Simple iterator that traverses the template arguments in a
6352 /// container that provides a \c getArgLoc() member function.
6353 ///
6354 /// This iterator is intended to be used with the iterator form of
6355 /// \c TreeTransform<Derived>::TransformTemplateArguments().
6356 template<typename ArgLocContainer>
6357 class TemplateArgumentLocContainerIterator {
6358 ArgLocContainer *Container;
6359 unsigned Index;
6360
6361 public:
6362 typedef TemplateArgumentLoc value_type;
6363 typedef TemplateArgumentLoc reference;
6364 typedef int difference_type;
6365 typedef std::input_iterator_tag iterator_category;
6366
6367 class pointer {
6368 TemplateArgumentLoc Arg;
6369
6370 public:
6371 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { }
6372
6373 const TemplateArgumentLoc *operator->() const {
6374 return &Arg;
6375 }
6376 };
6377
6378
6379 TemplateArgumentLocContainerIterator() {}
6380
6381 TemplateArgumentLocContainerIterator(ArgLocContainer &Container,
6382 unsigned Index)
6383 : Container(&Container), Index(Index) { }
6384
6385 TemplateArgumentLocContainerIterator &operator++() {
6386 ++Index;
6387 return *this;
6388 }
6389
6390 TemplateArgumentLocContainerIterator operator++(int) {
6391 TemplateArgumentLocContainerIterator Old(*this);
6392 ++(*this);
6393 return Old;
6394 }
6395
6396 TemplateArgumentLoc operator*() const {
6397 return Container->getArgLoc(Index);
6398 }
6399
6400 pointer operator->() const {
6401 return pointer(Container->getArgLoc(Index));
6402 }
6403
6404 friend bool operator==(const TemplateArgumentLocContainerIterator &X,
6405 const TemplateArgumentLocContainerIterator &Y) {
6406 return X.Container == Y.Container && X.Index == Y.Index;
6407 }
6408
6409 friend bool operator!=(const TemplateArgumentLocContainerIterator &X,
6410 const TemplateArgumentLocContainerIterator &Y) {
6411 return !(X == Y);
6412 }
6413 };
6414
6415template<typename Derived>
6416QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,
6417 AutoTypeLoc TL) {
6418 const AutoType *T = TL.getTypePtr();
6419 QualType OldDeduced = T->getDeducedType();
6420 QualType NewDeduced;
6421 if (!OldDeduced.isNull()) {
6422 NewDeduced = getDerived().TransformType(OldDeduced);
6423 if (NewDeduced.isNull())
6424 return QualType();
6425 }
6426
6427 ConceptDecl *NewCD = nullptr;
6428 TemplateArgumentListInfo NewTemplateArgs;
6429 NestedNameSpecifierLoc NewNestedNameSpec;
6430 if (TL.getTypePtr()->isConstrained()) {
6431 NewCD = cast_or_null<ConceptDecl>(
6432 getDerived().TransformDecl(
6433 TL.getConceptNameLoc(),
6434 TL.getTypePtr()->getTypeConstraintConcept()));
6435
6436 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
6437 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
6438 typedef TemplateArgumentLocContainerIterator<AutoTypeLoc> ArgIterator;
6439 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
6440 ArgIterator(TL,
6441 TL.getNumArgs()),
6442 NewTemplateArgs))
6443 return QualType();
6444
6445 if (TL.getNestedNameSpecifierLoc()) {
6446 NewNestedNameSpec
6447 = getDerived().TransformNestedNameSpecifierLoc(
6448 TL.getNestedNameSpecifierLoc());
6449 if (!NewNestedNameSpec)
6450 return QualType();
6451 }
6452 }
6453
6454 QualType Result = TL.getType();
6455 if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced ||
6456 T->isDependentType()) {
6457 llvm::SmallVector<TemplateArgument, 4> NewArgList;
6458 NewArgList.reserve(NewArgList.size());
6459 for (const auto &ArgLoc : NewTemplateArgs.arguments())
6460 NewArgList.push_back(ArgLoc.getArgument());
6461 Result = getDerived().RebuildAutoType(NewDeduced, T->getKeyword(), NewCD,
6462 NewArgList);
6463 if (Result.isNull())
6464 return QualType();
6465 }
6466
6467 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
6468 NewTL.setNameLoc(TL.getNameLoc());
6469 NewTL.setNestedNameSpecifierLoc(NewNestedNameSpec);
6470 NewTL.setTemplateKWLoc(TL.getTemplateKWLoc());
6471 NewTL.setConceptNameLoc(TL.getConceptNameLoc());
6472 NewTL.setFoundDecl(TL.getFoundDecl());
6473 NewTL.setLAngleLoc(TL.getLAngleLoc());
6474 NewTL.setRAngleLoc(TL.getRAngleLoc());
6475 for (unsigned I = 0; I < TL.getNumArgs(); ++I)
6476 NewTL.setArgLocInfo(I, NewTemplateArgs.arguments()[I].getLocInfo());
6477
6478 return Result;
6479}
6480
6481template <typename Derived>
6482QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
6483 TypeLocBuilder &TLB,
6484 TemplateSpecializationTypeLoc TL,
6485 TemplateName Template) {
6486 TemplateArgumentListInfo NewTemplateArgs;
6487 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
6488 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
6489 typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc>
6490 ArgIterator;
6491 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
6492 ArgIterator(TL, TL.getNumArgs()),
6493 NewTemplateArgs))
6494 return QualType();
6495
6496 // FIXME: maybe don't rebuild if all the template arguments are the same.
6497
6498 QualType Result =
6499 getDerived().RebuildTemplateSpecializationType(Template,
6500 TL.getTemplateNameLoc(),
6501 NewTemplateArgs);
6502
6503 if (!Result.isNull()) {
6504 // Specializations of template template parameters are represented as
6505 // TemplateSpecializationTypes, and substitution of type alias templates
6506 // within a dependent context can transform them into
6507 // DependentTemplateSpecializationTypes.
6508 if (isa<DependentTemplateSpecializationType>(Result)) {
6509 DependentTemplateSpecializationTypeLoc NewTL
6510 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
6511 NewTL.setElaboratedKeywordLoc(SourceLocation());
6512 NewTL.setQualifierLoc(NestedNameSpecifierLoc());
6513 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
6514 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
6515 NewTL.setLAngleLoc(TL.getLAngleLoc());
6516 NewTL.setRAngleLoc(TL.getRAngleLoc());
6517 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
6518 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
6519 return Result;
6520 }
6521
6522 TemplateSpecializationTypeLoc NewTL
6523 = TLB.push<TemplateSpecializationTypeLoc>(Result);
6524 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
6525 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
6526 NewTL.setLAngleLoc(TL.getLAngleLoc());
6527 NewTL.setRAngleLoc(TL.getRAngleLoc());
6528 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
6529 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
6530 }
6531
6532 return Result;
6533}
6534
6535template <typename Derived>
6536QualType TreeTransform<Derived>::TransformDependentTemplateSpecializationType(
6537 TypeLocBuilder &TLB,
6538 DependentTemplateSpecializationTypeLoc TL,
6539 TemplateName Template,
6540 CXXScopeSpec &SS) {
6541 TemplateArgumentListInfo NewTemplateArgs;
6542 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
6543 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
6544 typedef TemplateArgumentLocContainerIterator<
6545 DependentTemplateSpecializationTypeLoc> ArgIterator;
6546 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
6547 ArgIterator(TL, TL.getNumArgs()),
6548 NewTemplateArgs))
6549 return QualType();
6550
6551 // FIXME: maybe don't rebuild if all the template arguments are the same.
6552
6553 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
6554 QualType Result
6555 = getSema().Context.getDependentTemplateSpecializationType(
6556 TL.getTypePtr()->getKeyword(),
6557 DTN->getQualifier(),
6558 DTN->getIdentifier(),
6559 NewTemplateArgs);
6560
6561 DependentTemplateSpecializationTypeLoc NewTL
6562 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
6563 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
6564 NewTL.setQualifierLoc(SS.getWithLocInContext(SemaRef.Context));
6565 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
6566 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
6567 NewTL.setLAngleLoc(TL.getLAngleLoc());
6568 NewTL.setRAngleLoc(TL.getRAngleLoc());
6569 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
6570 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
6571 return Result;
6572 }
6573
6574 QualType Result
6575 = getDerived().RebuildTemplateSpecializationType(Template,
6576 TL.getTemplateNameLoc(),
6577 NewTemplateArgs);
6578
6579 if (!Result.isNull()) {
6580 /// FIXME: Wrap this in an elaborated-type-specifier?
6581 TemplateSpecializationTypeLoc NewTL
6582 = TLB.push<TemplateSpecializationTypeLoc>(Result);
6583 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
6584 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
6585 NewTL.setLAngleLoc(TL.getLAngleLoc());
6586 NewTL.setRAngleLoc(TL.getRAngleLoc());
6587 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
6588 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
6589 }
6590
6591 return Result;
6592}
6593
6594template<typename Derived>
6595QualType
6596TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB,
6597 ElaboratedTypeLoc TL) {
6598 const ElaboratedType *T = TL.getTypePtr();
6599
6600 NestedNameSpecifierLoc QualifierLoc;
6601 // NOTE: the qualifier in an ElaboratedType is optional.
6602 if (TL.getQualifierLoc()) {
6603 QualifierLoc
6604 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
6605 if (!QualifierLoc)
6606 return QualType();
6607 }
6608
6609 QualType NamedT = getDerived().TransformType(TLB, TL.getNamedTypeLoc());
6610 if (NamedT.isNull())
6611 return QualType();
6612
6613 // C++0x [dcl.type.elab]p2:
6614 // If the identifier resolves to a typedef-name or the simple-template-id
6615 // resolves to an alias template specialization, the
6616 // elaborated-type-specifier is ill-formed.
6617 if (T->getKeyword() != ETK_None && T->getKeyword() != ETK_Typename) {
6618 if (const TemplateSpecializationType *TST =
6619 NamedT->getAs<TemplateSpecializationType>()) {
6620 TemplateName Template = TST->getTemplateName();
6621 if (TypeAliasTemplateDecl *TAT = dyn_cast_or_null<TypeAliasTemplateDecl>(
6622 Template.getAsTemplateDecl())) {
6623 SemaRef.Diag(TL.getNamedTypeLoc().getBeginLoc(),
6624 diag::err_tag_reference_non_tag)
6625 << TAT << Sema::NTK_TypeAliasTemplate
6626 << ElaboratedType::getTagTypeKindForKeyword(T->getKeyword());
6627 SemaRef.Diag(TAT->getLocation(), diag::note_declared_at);
6628 }
6629 }
6630 }
6631
6632 QualType Result = TL.getType();
6633 if (getDerived().AlwaysRebuild() ||
6634 QualifierLoc != TL.getQualifierLoc() ||
6635 NamedT != T->getNamedType()) {
6636 Result = getDerived().RebuildElaboratedType(TL.getElaboratedKeywordLoc(),
6637 T->getKeyword(),
6638 QualifierLoc, NamedT);
6639 if (Result.isNull())
6640 return QualType();
6641 }
6642
6643 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
6644 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
6645 NewTL.setQualifierLoc(QualifierLoc);
6646 return Result;
6647}
6648
6649template<typename Derived>
6650QualType TreeTransform<Derived>::TransformAttributedType(
6651 TypeLocBuilder &TLB,
6652 AttributedTypeLoc TL) {
6653 const AttributedType *oldType = TL.getTypePtr();
6654 QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc());
6655 if (modifiedType.isNull())
6656 return QualType();
6657
6658 // oldAttr can be null if we started with a QualType rather than a TypeLoc.
6659 const Attr *oldAttr = TL.getAttr();
6660 const Attr *newAttr = oldAttr ? getDerived().TransformAttr(oldAttr) : nullptr;
6661 if (oldAttr && !newAttr)
6662 return QualType();
6663
6664 QualType result = TL.getType();
6665
6666 // FIXME: dependent operand expressions?
6667 if (getDerived().AlwaysRebuild() ||
6668 modifiedType != oldType->getModifiedType()) {
6669 // TODO: this is really lame; we should really be rebuilding the
6670 // equivalent type from first principles.
6671 QualType equivalentType
6672 = getDerived().TransformType(oldType->getEquivalentType());
6673 if (equivalentType.isNull())
6674 return QualType();
6675
6676 // Check whether we can add nullability; it is only represented as
6677 // type sugar, and therefore cannot be diagnosed in any other way.
6678 if (auto nullability = oldType->getImmediateNullability()) {
6679 if (!modifiedType->canHaveNullability()) {
6680 SemaRef.Diag(TL.getAttr()->getLocation(),
6681 diag::err_nullability_nonpointer)
6682 << DiagNullabilityKind(*nullability, false) << modifiedType;
6683 return QualType();
6684 }
6685 }
6686
6687 result = SemaRef.Context.getAttributedType(TL.getAttrKind(),
6688 modifiedType,
6689 equivalentType);
6690 }
6691
6692 AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result);
6693 newTL.setAttr(newAttr);
6694 return result;
6695}
6696
6697template<typename Derived>
6698QualType
6699TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB,
6700 ParenTypeLoc TL) {
6701 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
6702 if (Inner.isNull())
6703 return QualType();
6704
6705 QualType Result = TL.getType();
6706 if (getDerived().AlwaysRebuild() ||
6707 Inner != TL.getInnerLoc().getType()) {
6708 Result = getDerived().RebuildParenType(Inner);
6709 if (Result.isNull())
6710 return QualType();
6711 }
6712
6713 ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result);
6714 NewTL.setLParenLoc(TL.getLParenLoc());
6715 NewTL.setRParenLoc(TL.getRParenLoc());
6716 return Result;
6717}
6718
6719template <typename Derived>
6720QualType
6721TreeTransform<Derived>::TransformMacroQualifiedType(TypeLocBuilder &TLB,
6722 MacroQualifiedTypeLoc TL) {
6723 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
6724 if (Inner.isNull())
6725 return QualType();
6726
6727 QualType Result = TL.getType();
6728 if (getDerived().AlwaysRebuild() || Inner != TL.getInnerLoc().getType()) {
6729 Result =
6730 getDerived().RebuildMacroQualifiedType(Inner, TL.getMacroIdentifier());
6731 if (Result.isNull())
6732 return QualType();
6733 }
6734
6735 MacroQualifiedTypeLoc NewTL = TLB.push<MacroQualifiedTypeLoc>(Result);
6736 NewTL.setExpansionLoc(TL.getExpansionLoc());
6737 return Result;
6738}
6739
6740template<typename Derived>
6741QualType TreeTransform<Derived>::TransformDependentNameType(
6742 TypeLocBuilder &TLB, DependentNameTypeLoc TL) {
6743 return TransformDependentNameType(TLB, TL, false);
6744}
6745
6746template<typename Derived>
6747QualType TreeTransform<Derived>::TransformDependentNameType(
6748 TypeLocBuilder &TLB, DependentNameTypeLoc TL, bool DeducedTSTContext) {
6749 const DependentNameType *T = TL.getTypePtr();
6750
6751 NestedNameSpecifierLoc QualifierLoc
6752 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
6753 if (!QualifierLoc)
6754 return QualType();
6755
6756 QualType Result
6757 = getDerived().RebuildDependentNameType(T->getKeyword(),
6758 TL.getElaboratedKeywordLoc(),
6759 QualifierLoc,
6760 T->getIdentifier(),
6761 TL.getNameLoc(),
6762 DeducedTSTContext);
6763 if (Result.isNull())
6764 return QualType();
6765
6766 if (const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) {
6767 QualType NamedT = ElabT->getNamedType();
6768 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc());
6769
6770 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
6771 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
6772 NewTL.setQualifierLoc(QualifierLoc);
6773 } else {
6774 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result);
6775 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
6776 NewTL.setQualifierLoc(QualifierLoc);
6777 NewTL.setNameLoc(TL.getNameLoc());
6778 }
6779 return Result;
6780}
6781
6782template<typename Derived>
6783QualType TreeTransform<Derived>::
6784 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
6785 DependentTemplateSpecializationTypeLoc TL) {
6786 NestedNameSpecifierLoc QualifierLoc;
6787 if (TL.getQualifierLoc()) {
6788 QualifierLoc
6789 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
6790 if (!QualifierLoc)
6791 return QualType();
6792 }
6793
6794 return getDerived()
6795 .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc);
6796}
6797
6798template<typename Derived>
6799QualType TreeTransform<Derived>::
6800TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
6801 DependentTemplateSpecializationTypeLoc TL,
6802 NestedNameSpecifierLoc QualifierLoc) {
6803 const DependentTemplateSpecializationType *T = TL.getTypePtr();
6804
6805 TemplateArgumentListInfo NewTemplateArgs;
6806 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
6807 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
6808
6809 typedef TemplateArgumentLocContainerIterator<
6810 DependentTemplateSpecializationTypeLoc> ArgIterator;
6811 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
6812 ArgIterator(TL, TL.getNumArgs()),
6813 NewTemplateArgs))
6814 return QualType();
6815
6816 QualType Result = getDerived().RebuildDependentTemplateSpecializationType(
6817 T->getKeyword(), QualifierLoc, TL.getTemplateKeywordLoc(),
6818 T->getIdentifier(), TL.getTemplateNameLoc(), NewTemplateArgs,
6819 /*AllowInjectedClassName*/ false);
6820 if (Result.isNull())
6821 return QualType();
6822
6823 if (const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) {
6824 QualType NamedT = ElabT->getNamedType();
6825
6826 // Copy information relevant to the template specialization.
6827 TemplateSpecializationTypeLoc NamedTL
6828 = TLB.push<TemplateSpecializationTypeLoc>(NamedT);
6829 NamedTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
6830 NamedTL.setTemplateNameLoc(TL.getTemplateNameLoc());
6831 NamedTL.setLAngleLoc(TL.getLAngleLoc());
6832 NamedTL.setRAngleLoc(TL.getRAngleLoc());
6833 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
6834 NamedTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());
6835
6836 // Copy information relevant to the elaborated type.
6837 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
6838 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
6839 NewTL.setQualifierLoc(QualifierLoc);
6840 } else if (isa<DependentTemplateSpecializationType>(Result)) {
6841 DependentTemplateSpecializationTypeLoc SpecTL
6842 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
6843 SpecTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
6844 SpecTL.setQualifierLoc(QualifierLoc);
6845 SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
6846 SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc());
6847 SpecTL.setLAngleLoc(TL.getLAngleLoc());
6848 SpecTL.setRAngleLoc(TL.getRAngleLoc());
6849 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
6850 SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());
6851 } else {
6852 TemplateSpecializationTypeLoc SpecTL
6853 = TLB.push<TemplateSpecializationTypeLoc>(Result);
6854 SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
6855 SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc());
6856 SpecTL.setLAngleLoc(TL.getLAngleLoc());
6857 SpecTL.setRAngleLoc(TL.getRAngleLoc());
6858 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I)
6859 SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo());
6860 }
6861 return Result;
6862}
6863
6864template<typename Derived>
6865QualType TreeTransform<Derived>::TransformPackExpansionType(TypeLocBuilder &TLB,
6866 PackExpansionTypeLoc TL) {
6867 QualType Pattern
6868 = getDerived().TransformType(TLB, TL.getPatternLoc());
6869 if (Pattern.isNull())
6870 return QualType();
6871
6872 QualType Result = TL.getType();
6873 if (getDerived().AlwaysRebuild() ||
6874 Pattern != TL.getPatternLoc().getType()) {
6875 Result = getDerived().RebuildPackExpansionType(Pattern,
6876 TL.getPatternLoc().getSourceRange(),
6877 TL.getEllipsisLoc(),
6878 TL.getTypePtr()->getNumExpansions());
6879 if (Result.isNull())
6880 return QualType();
6881 }
6882
6883 PackExpansionTypeLoc NewT = TLB.push<PackExpansionTypeLoc>(Result);
6884 NewT.setEllipsisLoc(TL.getEllipsisLoc());
6885 return Result;
6886}
6887
6888template<typename Derived>
6889QualType
6890TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB,
6891 ObjCInterfaceTypeLoc TL) {
6892 // ObjCInterfaceType is never dependent.
6893 TLB.pushFullCopy(TL);
6894 return TL.getType();
6895}
6896
6897template<typename Derived>
6898QualType
6899TreeTransform<Derived>::TransformObjCTypeParamType(TypeLocBuilder &TLB,
6900 ObjCTypeParamTypeLoc TL) {
6901 const ObjCTypeParamType *T = TL.getTypePtr();
6902 ObjCTypeParamDecl *OTP = cast_or_null<ObjCTypeParamDecl>(
6903 getDerived().TransformDecl(T->getDecl()->getLocation(), T->getDecl()));
6904 if (!OTP)
6905 return QualType();
6906
6907 QualType Result = TL.getType();
6908 if (getDerived().AlwaysRebuild() ||
6909 OTP != T->getDecl()) {
6910 Result = getDerived().RebuildObjCTypeParamType(OTP,
6911 TL.getProtocolLAngleLoc(),
6912 llvm::makeArrayRef(TL.getTypePtr()->qual_begin(),
6913 TL.getNumProtocols()),
6914 TL.getProtocolLocs(),
6915 TL.getProtocolRAngleLoc());
6916 if (Result.isNull())
6917 return QualType();
6918 }
6919
6920 ObjCTypeParamTypeLoc NewTL = TLB.push<ObjCTypeParamTypeLoc>(Result);
6921 if (TL.getNumProtocols()) {
6922 NewTL.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
6923 for (unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
6924 NewTL.setProtocolLoc(i, TL.getProtocolLoc(i));
6925 NewTL.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
6926 }
6927 return Result;
6928}
6929
6930template<typename Derived>
6931QualType
6932TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,
6933 ObjCObjectTypeLoc TL) {
6934 // Transform base type.
6935 QualType BaseType = getDerived().TransformType(TLB, TL.getBaseLoc());
6936 if (BaseType.isNull())
6937 return QualType();
6938
6939 bool AnyChanged = BaseType != TL.getBaseLoc().getType();
6940
6941 // Transform type arguments.
6942 SmallVector<TypeSourceInfo *, 4> NewTypeArgInfos;
6943 for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) {
6944 TypeSourceInfo *TypeArgInfo = TL.getTypeArgTInfo(i);
6945 TypeLoc TypeArgLoc = TypeArgInfo->getTypeLoc();
6946 QualType TypeArg = TypeArgInfo->getType();
6947 if (auto PackExpansionLoc = TypeArgLoc.getAs<PackExpansionTypeLoc>()) {
6948 AnyChanged = true;
6949
6950 // We have a pack expansion. Instantiate it.
6951 const auto *PackExpansion = PackExpansionLoc.getType()
6952 ->castAs<PackExpansionType>();
6953 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
6954 SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
6955 Unexpanded);
6956 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
6957
6958 // Determine whether the set of unexpanded parameter packs can
6959 // and should be expanded.
6960 TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc();
6961 bool Expand = false;
6962 bool RetainExpansion = false;
6963 Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
6964 if (getDerived().TryExpandParameterPacks(
6965 PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(),
6966 Unexpanded, Expand, RetainExpansion, NumExpansions))
6967 return QualType();
6968
6969 if (!Expand) {
6970 // We can't expand this pack expansion into separate arguments yet;
6971 // just substitute into the pattern and create a new pack expansion
6972 // type.
6973 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
6974
6975 TypeLocBuilder TypeArgBuilder;
6976 TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
6977 QualType NewPatternType = getDerived().TransformType(TypeArgBuilder,
6978 PatternLoc);
6979 if (NewPatternType.isNull())
6980 return QualType();
6981
6982 QualType NewExpansionType = SemaRef.Context.getPackExpansionType(
6983 NewPatternType, NumExpansions);
6984 auto NewExpansionLoc = TLB.push<PackExpansionTypeLoc>(NewExpansionType);
6985 NewExpansionLoc.setEllipsisLoc(PackExpansionLoc.getEllipsisLoc());
6986 NewTypeArgInfos.push_back(
6987 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewExpansionType));
6988 continue;
6989 }
6990
6991 // Substitute into the pack expansion pattern for each slice of the
6992 // pack.
6993 for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
6994 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);
6995
6996 TypeLocBuilder TypeArgBuilder;
6997 TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
6998
6999 QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder,
7000 PatternLoc);
7001 if (NewTypeArg.isNull())
7002 return QualType();
7003
7004 NewTypeArgInfos.push_back(
7005 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
7006 }
7007
7008 continue;
7009 }
7010
7011 TypeLocBuilder TypeArgBuilder;
7012 TypeArgBuilder.reserve(TypeArgLoc.getFullDataSize());
7013 QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder, TypeArgLoc);
7014 if (NewTypeArg.isNull())
7015 return QualType();
7016
7017 // If nothing changed, just keep the old TypeSourceInfo.
7018 if (NewTypeArg == TypeArg) {
7019 NewTypeArgInfos.push_back(TypeArgInfo);
7020 continue;
7021 }
7022
7023 NewTypeArgInfos.push_back(
7024 TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
7025 AnyChanged = true;
7026 }
7027
7028 QualType Result = TL.getType();
7029 if (getDerived().AlwaysRebuild() || AnyChanged) {
7030 // Rebuild the type.
7031 Result = getDerived().RebuildObjCObjectType(
7032 BaseType, TL.getBeginLoc(), TL.getTypeArgsLAngleLoc(), NewTypeArgInfos,
7033 TL.getTypeArgsRAngleLoc(), TL.getProtocolLAngleLoc(),
7034 llvm::makeArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()),
7035 TL.getProtocolLocs(), TL.getProtocolRAngleLoc());
7036
7037 if (Result.isNull())
7038 return QualType();
7039 }
7040
7041 ObjCObjectTypeLoc NewT = TLB.push<ObjCObjectTypeLoc>(Result);
7042 NewT.setHasBaseTypeAsWritten(true);
7043 NewT.setTypeArgsLAngleLoc(TL.getTypeArgsLAngleLoc());
7044 for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i)
7045 NewT.setTypeArgTInfo(i, NewTypeArgInfos[i]);
7046 NewT.setTypeArgsRAngleLoc(TL.getTypeArgsRAngleLoc());
7047 NewT.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
7048 for (unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
7049 NewT.setProtocolLoc(i, TL.getProtocolLoc(i));
7050 NewT.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
7051 return Result;
7052}
7053
7054template<typename Derived>
7055QualType
7056TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,
7057 ObjCObjectPointerTypeLoc TL) {
7058 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
7059 if (PointeeType.isNull())
7060 return QualType();
7061
7062 QualType Result = TL.getType();
7063 if (getDerived().AlwaysRebuild() ||
7064 PointeeType != TL.getPointeeLoc().getType()) {
7065 Result = getDerived().RebuildObjCObjectPointerType(PointeeType,
7066 TL.getStarLoc());
7067 if (Result.isNull())
7068 return QualType();
7069 }
7070
7071 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
7072 NewT.setStarLoc(TL.getStarLoc());
7073 return Result;
7074}
7075
7076//===----------------------------------------------------------------------===//
7077// Statement transformation
7078//===----------------------------------------------------------------------===//
7079template<typename Derived>
7080StmtResult
7081TreeTransform<Derived>::TransformNullStmt(NullStmt *S) {
7082 return S;
7083}
7084
7085template<typename Derived>
7086StmtResult
7087TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) {
7088 return getDerived().TransformCompoundStmt(S, false);
7089}
7090
7091template<typename Derived>
7092StmtResult
7093TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S,
7094 bool IsStmtExpr) {
7095 Sema::CompoundScopeRAII CompoundScope(getSema());
7096
7097 const Stmt *ExprResult = S->getStmtExprResult();
7098 bool SubStmtInvalid = false;
7099 bool SubStmtChanged = false;
7100 SmallVector<Stmt*, 8> Statements;
7101 for (auto *B : S->body()) {
7102 StmtResult Result = getDerived().TransformStmt(
7103 B, IsStmtExpr && B == ExprResult ? SDK_StmtExprResult : SDK_Discarded);
7104
7105 if (Result.isInvalid()) {
7106 // Immediately fail if this was a DeclStmt, since it's very
7107 // likely that this will cause problems for future statements.
7108 if (isa<DeclStmt>(B))
7109 return StmtError();
7110
7111 // Otherwise, just keep processing substatements and fail later.
7112 SubStmtInvalid = true;
7113 continue;
7114 }
7115
7116 SubStmtChanged = SubStmtChanged || Result.get() != B;
7117 Statements.push_back(Result.getAs<Stmt>());
7118 }
7119
7120 if (SubStmtInvalid)
7121 return StmtError();
7122
7123 if (!getDerived().AlwaysRebuild() &&
7124 !SubStmtChanged)
7125 return S;
7126
7127 return getDerived().RebuildCompoundStmt(S->getLBracLoc(),
7128 Statements,
7129 S->getRBracLoc(),
7130 IsStmtExpr);
7131}
7132
7133template<typename Derived>
7134StmtResult
7135TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) {
7136 ExprResult LHS, RHS;
7137 {
7138 EnterExpressionEvaluationContext Unevaluated(
7139 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
7140
7141 // Transform the left-hand case value.
7142 LHS = getDerived().TransformExpr(S->getLHS());
7143 LHS = SemaRef.ActOnCaseExpr(S->getCaseLoc(), LHS);
7144 if (LHS.isInvalid())
7145 return StmtError();
7146
7147 // Transform the right-hand case value (for the GNU case-range extension).
7148 RHS = getDerived().TransformExpr(S->getRHS());
7149 RHS = SemaRef.ActOnCaseExpr(S->getCaseLoc(), RHS);
7150 if (RHS.isInvalid())
7151 return StmtError();
7152 }
7153
7154 // Build the case statement.
7155 // Case statements are always rebuilt so that they will attached to their
7156 // transformed switch statement.
7157 StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),
7158 LHS.get(),
7159 S->getEllipsisLoc(),
7160 RHS.get(),
7161 S->getColonLoc());
7162 if (Case.isInvalid())
7163 return StmtError();
7164
7165 // Transform the statement following the case
7166 StmtResult SubStmt =
7167 getDerived().TransformStmt(S->getSubStmt());
7168 if (SubStmt.isInvalid())
7169 return StmtError();
7170
7171 // Attach the body to the case statement
7172 return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get());
7173}
7174
7175template <typename Derived>
7176StmtResult TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) {
7177 // Transform the statement following the default case
7178 StmtResult SubStmt =
7179 getDerived().TransformStmt(S->getSubStmt());
7180 if (SubStmt.isInvalid())
7181 return StmtError();
7182
7183 // Default statements are always rebuilt
7184 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
7185 SubStmt.get());
7186}
7187
7188template<typename Derived>
7189StmtResult
7190TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S, StmtDiscardKind SDK) {
7191 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK);
7192 if (SubStmt.isInvalid())
7193 return StmtError();
7194
7195 Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(),
7196 S->getDecl());
7197 if (!LD)
7198 return StmtError();
7199
7200 // If we're transforming "in-place" (we're not creating new local
7201 // declarations), assume we're replacing the old label statement
7202 // and clear out the reference to it.
7203 if (LD == S->getDecl())
7204 S->getDecl()->setStmt(nullptr);
7205
7206 // FIXME: Pass the real colon location in.
7207 return getDerived().RebuildLabelStmt(S->getIdentLoc(),
7208 cast<LabelDecl>(LD), SourceLocation(),
7209 SubStmt.get());
7210}
7211
7212template <typename Derived>
7213const Attr *TreeTransform<Derived>::TransformAttr(const Attr *R) {
7214 if (!R)
7215 return R;
7216
7217 switch (R->getKind()) {
7218// Transform attributes with a pragma spelling by calling TransformXXXAttr.
7219#define ATTR(X)
7220#define PRAGMA_SPELLING_ATTR(X) \
7221 case attr::X: \
7222 return getDerived().Transform##X##Attr(cast<X##Attr>(R));
7223#include "clang/Basic/AttrList.inc"
7224 default:
7225 return R;
7226 }
7227}
7228
7229template <typename Derived>
7230StmtResult
7231TreeTransform<Derived>::TransformAttributedStmt(AttributedStmt *S,
7232 StmtDiscardKind SDK) {
7233 bool AttrsChanged = false;
7234 SmallVector<const Attr *, 1> Attrs;
7235
7236 // Visit attributes and keep track if any are transformed.
7237 for (const auto *I : S->getAttrs()) {
7238 const Attr *R = getDerived().TransformAttr(I);
7239 AttrsChanged |= (I != R);
7240 Attrs.push_back(R);
7241 }
7242
7243 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK);
7244 if (SubStmt.isInvalid())
7245 return StmtError();
7246
7247 if (SubStmt.get() == S->getSubStmt() && !AttrsChanged)
7248 return S;
7249
7250 return getDerived().RebuildAttributedStmt(S->getAttrLoc(), Attrs,
7251 SubStmt.get());
7252}
7253
7254template<typename Derived>
7255StmtResult
7256TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
7257 // Transform the initialization statement
7258 StmtResult Init = getDerived().TransformStmt(S->getInit());
7259 if (Init.isInvalid())
7260 return StmtError();
7261
7262 // Transform the condition
7263 Sema::ConditionResult Cond = getDerived().TransformCondition(
7264 S->getIfLoc(), S->getConditionVariable(), S->getCond(),
7265 S->isConstexpr() ? Sema::ConditionKind::ConstexprIf
7266 : Sema::ConditionKind::Boolean);
7267 if (Cond.isInvalid())
7268 return StmtError();
7269
7270 // If this is a constexpr if, determine which arm we should instantiate.
7271 llvm::Optional<bool> ConstexprConditionValue;
7272 if (S->isConstexpr())
7273 ConstexprConditionValue = Cond.getKnownValue();
7274
7275 // Transform the "then" branch.
7276 StmtResult Then;
7277 if (!ConstexprConditionValue || *ConstexprConditionValue) {
7278 Then = getDerived().TransformStmt(S->getThen());
7279 if (Then.isInvalid())
7280 return StmtError();
7281 } else {
7282 Then = new (getSema().Context) NullStmt(S->getThen()->getBeginLoc());
7283 }
7284
7285 // Transform the "else" branch.
7286 StmtResult Else;
7287 if (!ConstexprConditionValue || !*ConstexprConditionValue) {
7288 Else = getDerived().TransformStmt(S->getElse());
7289 if (Else.isInvalid())
7290 return StmtError();
7291 }
7292
7293 if (!getDerived().AlwaysRebuild() &&
7294 Init.get() == S->getInit() &&
7295 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
7296 Then.get() == S->getThen() &&
7297 Else.get() == S->getElse())
7298 return S;
7299
7300 return getDerived().RebuildIfStmt(
7301 S->getIfLoc(), S->isConstexpr(), S->getLParenLoc(), Cond,
7302 S->getRParenLoc(), Init.get(), Then.get(), S->getElseLoc(), Else.get());
7303}
7304
7305template<typename Derived>
7306StmtResult
7307TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
7308 // Transform the initialization statement
7309 StmtResult Init = getDerived().TransformStmt(S->getInit());
7310 if (Init.isInvalid())
7311 return StmtError();
7312
7313 // Transform the condition.
7314 Sema::ConditionResult Cond = getDerived().TransformCondition(
7315 S->getSwitchLoc(), S->getConditionVariable(), S->getCond(),
7316 Sema::ConditionKind::Switch);
7317 if (Cond.isInvalid())
7318 return StmtError();
7319
7320 // Rebuild the switch statement.
7321 StmtResult Switch =
7322 getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), S->getLParenLoc(),
7323 Init.get(), Cond, S->getRParenLoc());
7324 if (Switch.isInvalid())
7325 return StmtError();
7326
7327 // Transform the body of the switch statement.
7328 StmtResult Body = getDerived().TransformStmt(S->getBody());
7329 if (Body.isInvalid())
7330 return StmtError();
7331
7332 // Complete the switch statement.
7333 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(),
7334 Body.get());
7335}
7336
7337template<typename Derived>
7338StmtResult
7339TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) {
7340 // Transform the condition
7341 Sema::ConditionResult Cond = getDerived().TransformCondition(
7342 S->getWhileLoc(), S->getConditionVariable(), S->getCond(),
7343 Sema::ConditionKind::Boolean);
7344 if (Cond.isInvalid())
7345 return StmtError();
7346
7347 // Transform the body
7348 StmtResult Body = getDerived().TransformStmt(S->getBody());
7349 if (Body.isInvalid())
7350 return StmtError();
7351
7352 if (!getDerived().AlwaysRebuild() &&
7353 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
7354 Body.get() == S->getBody())
7355 return Owned(S);
7356
7357 return getDerived().RebuildWhileStmt(S->getWhileLoc(), S->getLParenLoc(),
7358 Cond, S->getRParenLoc(), Body.get());
7359}
7360
7361template<typename Derived>
7362StmtResult
7363TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {
7364 // Transform the body
7365 StmtResult Body = getDerived().TransformStmt(S->getBody());
7366 if (Body.isInvalid())
7367 return StmtError();
7368
7369 // Transform the condition
7370 ExprResult Cond = getDerived().TransformExpr(S->getCond());
7371 if (Cond.isInvalid())
7372 return StmtError();
7373
7374 if (!getDerived().AlwaysRebuild() &&
7375 Cond.get() == S->getCond() &&
7376 Body.get() == S->getBody())
7377 return S;
7378
7379 return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(),
7380 /*FIXME:*/S->getWhileLoc(), Cond.get(),
7381 S->getRParenLoc());
7382}
7383
7384template<typename Derived>
7385StmtResult
7386TreeTransform<Derived>::TransformForStmt(ForStmt *S) {
7387 if (getSema().getLangOpts().OpenMP)
7388 getSema().startOpenMPLoop();
7389
7390 // Transform the initialization statement
7391 StmtResult Init = getDerived().TransformStmt(S->getInit());
7392 if (Init.isInvalid())
7393 return StmtError();
7394
7395 // In OpenMP loop region loop control variable must be captured and be
7396 // private. Perform analysis of first part (if any).
7397 if (getSema().getLangOpts().OpenMP && Init.isUsable())
7398 getSema().ActOnOpenMPLoopInitialization(S->getForLoc(), Init.get());
7399
7400 // Transform the condition
7401 Sema::ConditionResult Cond = getDerived().TransformCondition(
7402 S->getForLoc(), S->getConditionVariable(), S->getCond(),
7403 Sema::ConditionKind::Boolean);
7404 if (Cond.isInvalid())
7405 return StmtError();
7406
7407 // Transform the increment
7408 ExprResult Inc = getDerived().TransformExpr(S->getInc());
7409 if (Inc.isInvalid())
7410 return StmtError();
7411
7412 Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(Inc.get()));
7413 if (S->getInc() && !FullInc.get())
7414 return StmtError();
7415
7416 // Transform the body
7417 StmtResult Body = getDerived().TransformStmt(S->getBody());
7418 if (Body.isInvalid())
7419 return StmtError();
7420
7421 if (!getDerived().AlwaysRebuild() &&
7422 Init.get() == S->getInit() &&
7423 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
7424 Inc.get() == S->getInc() &&
7425 Body.get() == S->getBody())
7426 return S;
7427
7428 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),
7429 Init.get(), Cond, FullInc,
7430 S->getRParenLoc(), Body.get());
7431}
7432
7433template<typename Derived>
7434StmtResult
7435TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {
7436 Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(),
7437 S->getLabel());
7438 if (!LD)
7439 return StmtError();
7440
7441 // Goto statements must always be rebuilt, to resolve the label.
7442 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
7443 cast<LabelDecl>(LD));
7444}
7445
7446template<typename Derived>
7447StmtResult
7448TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
7449 ExprResult Target = getDerived().TransformExpr(S->getTarget());
7450 if (Target.isInvalid())
7451 return StmtError();
7452 Target = SemaRef.MaybeCreateExprWithCleanups(Target.get());
7453
7454 if (!getDerived().AlwaysRebuild() &&
7455 Target.get() == S->getTarget())
7456 return S;
7457
7458 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
7459 Target.get());
7460}
7461
7462template<typename Derived>
7463StmtResult
7464TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {
7465 return S;
7466}
7467
7468template<typename Derived>
7469StmtResult
7470TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {
7471 return S;
7472}
7473
7474template<typename Derived>
7475StmtResult
7476TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
7477 ExprResult Result = getDerived().TransformInitializer(S->getRetValue(),
7478 /*NotCopyInit*/false);
7479 if (Result.isInvalid())
7480 return StmtError();
7481
7482 // FIXME: We always rebuild the return statement because there is no way
7483 // to tell whether the return type of the function has changed.
7484 return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get());
7485}
7486
7487template<typename Derived>
7488StmtResult
7489TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {
7490 bool DeclChanged = false;
7491 SmallVector<Decl *, 4> Decls;
7492 for (auto *D : S->decls()) {
7493 Decl *Transformed = getDerived().TransformDefinition(D->getLocation(), D);
7494 if (!Transformed)
7495 return StmtError();
7496
7497 if (Transformed != D)
7498 DeclChanged = true;
7499
7500 Decls.push_back(Transformed);
7501 }
7502
7503 if (!getDerived().AlwaysRebuild() && !DeclChanged)
7504 return S;
7505
7506 return getDerived().RebuildDeclStmt(Decls, S->getBeginLoc(), S->getEndLoc());
7507}
7508
7509template<typename Derived>
7510StmtResult
7511TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) {
7512
7513 SmallVector<Expr*, 8> Constraints;
7514 SmallVector<Expr*, 8> Exprs;
7515 SmallVector<IdentifierInfo *, 4> Names;
7516
7517 ExprResult AsmString;
7518 SmallVector<Expr*, 8> Clobbers;
7519
7520 bool ExprsChanged = false;
7521
7522 // Go through the outputs.
7523 for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) {
7524 Names.push_back(S->getOutputIdentifier(I));
7525
7526 // No need to transform the constraint literal.
7527 Constraints.push_back(S->getOutputConstraintLiteral(I));
7528
7529 // Transform the output expr.
7530 Expr *OutputExpr = S->getOutputExpr(I);
7531 ExprResult Result = getDerived().TransformExpr(OutputExpr);
7532 if (Result.isInvalid())
7533 return StmtError();
7534
7535 ExprsChanged |= Result.get() != OutputExpr;
7536
7537 Exprs.push_back(Result.get());
7538 }
7539
7540 // Go through the inputs.
7541 for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) {
7542 Names.push_back(S->getInputIdentifier(I));
7543
7544 // No need to transform the constraint literal.
7545 Constraints.push_back(S->getInputConstraintLiteral(I));
7546
7547 // Transform the input expr.
7548 Expr *InputExpr = S->getInputExpr(I);
7549 ExprResult Result = getDerived().TransformExpr(InputExpr);
7550 if (Result.isInvalid())
7551 return StmtError();
7552
7553 ExprsChanged |= Result.get() != InputExpr;
7554
7555 Exprs.push_back(Result.get());
7556 }
7557
7558 // Go through the Labels.
7559 for (unsigned I = 0, E = S->getNumLabels(); I != E; ++I) {
7560 Names.push_back(S->getLabelIdentifier(I));
7561
7562 ExprResult Result = getDerived().TransformExpr(S->getLabelExpr(I));
7563 if (Result.isInvalid())
7564 return StmtError();
7565 ExprsChanged |= Result.get() != S->getLabelExpr(I);
7566 Exprs.push_back(Result.get());
7567 }
7568 if (!getDerived().AlwaysRebuild() && !ExprsChanged)
7569 return S;
7570
7571 // Go through the clobbers.
7572 for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I)
7573 Clobbers.push_back(S->getClobberStringLiteral(I));
7574
7575 // No need to transform the asm string literal.
7576 AsmString = S->getAsmString();
7577 return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(),
7578 S->isVolatile(), S->getNumOutputs(),
7579 S->getNumInputs(), Names.data(),
7580 Constraints, Exprs, AsmString.get(),
7581 Clobbers, S->getNumLabels(),
7582 S->getRParenLoc());
7583}
7584
7585template<typename Derived>
7586StmtResult
7587TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) {
7588 ArrayRef<Token> AsmToks =
7589 llvm::makeArrayRef(S->getAsmToks(), S->getNumAsmToks());
7590
7591 bool HadError = false, HadChange = false;
7592
7593 ArrayRef<Expr*> SrcExprs = S->getAllExprs();
7594 SmallVector<Expr*, 8> TransformedExprs;
7595 TransformedExprs.reserve(SrcExprs.size());
7596 for (unsigned i = 0, e = SrcExprs.size(); i != e; ++i) {
7597 ExprResult Result = getDerived().TransformExpr(SrcExprs[i]);
7598 if (!Result.isUsable()) {
7599 HadError = true;
7600 } else {
7601 HadChange |= (Result.get() != SrcExprs[i]);
7602 TransformedExprs.push_back(Result.get());
7603 }
7604 }
7605
7606 if (HadError) return StmtError();
7607 if (!HadChange && !getDerived().AlwaysRebuild())
7608 return Owned(S);
7609
7610 return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(),
7611 AsmToks, S->getAsmString(),
7612 S->getNumOutputs(), S->getNumInputs(),
7613 S->getAllConstraints(), S->getClobbers(),
7614 TransformedExprs, S->getEndLoc());
7615}
7616
7617// C++ Coroutines TS
7618
7619template<typename Derived>
7620StmtResult
7621TreeTransform<Derived>::TransformCoroutineBodyStmt(CoroutineBodyStmt *S) {
7622 auto *ScopeInfo = SemaRef.getCurFunction();
7623 auto *FD = cast<FunctionDecl>(SemaRef.CurContext);
7624 assert(FD && ScopeInfo && !ScopeInfo->CoroutinePromise &&
7625 ScopeInfo->NeedsCoroutineSuspends &&
7626 ScopeInfo->CoroutineSuspends.first == nullptr &&
7627 ScopeInfo->CoroutineSuspends.second == nullptr &&
7628 "expected clean scope info");
7629
7630 // Set that we have (possibly-invalid) suspend points before we do anything
7631 // that may fail.
7632 ScopeInfo->setNeedsCoroutineSuspends(false);
7633
7634 // We re-build the coroutine promise object (and the coroutine parameters its
7635 // type and constructor depend on) based on the types used in our current
7636 // function. We must do so, and set it on the current FunctionScopeInfo,
7637 // before attempting to transform the other parts of the coroutine body
7638 // statement, such as the implicit suspend statements (because those
7639 // statements reference the FunctionScopeInfo::CoroutinePromise).
7640 if (!SemaRef.buildCoroutineParameterMoves(FD->getLocation()))
7641 return StmtError();
7642 auto *Promise = SemaRef.buildCoroutinePromise(FD->getLocation());
7643 if (!Promise)
7644 return StmtError();
7645 getDerived().transformedLocalDecl(S->getPromiseDecl(), {Promise});
7646 ScopeInfo->CoroutinePromise = Promise;
7647
7648 // Transform the implicit coroutine statements constructed using dependent
7649 // types during the previous parse: initial and final suspensions, the return
7650 // object, and others. We also transform the coroutine function's body.
7651 StmtResult InitSuspend = getDerived().TransformStmt(S->getInitSuspendStmt());
7652 if (InitSuspend.isInvalid())
7653 return StmtError();
7654 StmtResult FinalSuspend =
7655 getDerived().TransformStmt(S->getFinalSuspendStmt());
7656 if (FinalSuspend.isInvalid() ||
7657 !SemaRef.checkFinalSuspendNoThrow(FinalSuspend.get()))
7658 return StmtError();
7659 ScopeInfo->setCoroutineSuspends(InitSuspend.get(), FinalSuspend.get());
7660 assert(isa<Expr>(InitSuspend.get()) && isa<Expr>(FinalSuspend.get()));
7661
7662 StmtResult BodyRes = getDerived().TransformStmt(S->getBody());
7663 if (BodyRes.isInvalid())
7664 return StmtError();
7665
7666 CoroutineStmtBuilder Builder(SemaRef, *FD, *ScopeInfo, BodyRes.get());
7667 if (Builder.isInvalid())
7668 return StmtError();
7669
7670 Expr *ReturnObject = S->getReturnValueInit();
7671 assert(ReturnObject && "the return object is expected to be valid");
7672 ExprResult Res = getDerived().TransformInitializer(ReturnObject,
7673 /*NoCopyInit*/ false);
7674 if (Res.isInvalid())
7675 return StmtError();
7676 Builder.ReturnValue = Res.get();
7677
7678 // If during the previous parse the coroutine still had a dependent promise
7679 // statement, we may need to build some implicit coroutine statements
7680 // (such as exception and fallthrough handlers) for the first time.
7681 if (S->hasDependentPromiseType()) {
7682 // We can only build these statements, however, if the current promise type
7683 // is not dependent.
7684 if (!Promise->getType()->isDependentType()) {
7685 assert(!S->getFallthroughHandler() && !S->getExceptionHandler() &&
7686 !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() &&
7687 "these nodes should not have been built yet");
7688 if (!Builder.buildDependentStatements())
7689 return StmtError();
7690 }
7691 } else {
7692 if (auto *OnFallthrough = S->getFallthroughHandler()) {
7693 StmtResult Res = getDerived().TransformStmt(OnFallthrough);
7694 if (Res.isInvalid())
7695 return StmtError();
7696 Builder.OnFallthrough = Res.get();
7697 }
7698
7699 if (auto *OnException = S->getExceptionHandler()) {
7700 StmtResult Res = getDerived().TransformStmt(OnException);
7701 if (Res.isInvalid())
7702 return StmtError();
7703 Builder.OnException = Res.get();
7704 }
7705
7706 if (auto *OnAllocFailure = S->getReturnStmtOnAllocFailure()) {
7707 StmtResult Res = getDerived().TransformStmt(OnAllocFailure);
7708 if (Res.isInvalid())
7709 return StmtError();
7710 Builder.ReturnStmtOnAllocFailure = Res.get();
7711 }
7712
7713 // Transform any additional statements we may have already built
7714 assert(S->getAllocate() && S->getDeallocate() &&
7715 "allocation and deallocation calls must already be built");
7716 ExprResult AllocRes = getDerived().TransformExpr(S->getAllocate());
7717 if (AllocRes.isInvalid())
7718 return StmtError();
7719 Builder.Allocate = AllocRes.get();
7720
7721 ExprResult DeallocRes = getDerived().TransformExpr(S->getDeallocate());
7722 if (DeallocRes.isInvalid())
7723 return StmtError();
7724 Builder.Deallocate = DeallocRes.get();
7725
7726 assert(S->getResultDecl() && "ResultDecl must already be built");
7727 StmtResult ResultDecl = getDerived().TransformStmt(S->getResultDecl());
7728 if (ResultDecl.isInvalid())
7729 return StmtError();
7730 Builder.ResultDecl = ResultDecl.get();
7731
7732 if (auto *ReturnStmt = S->getReturnStmt()) {
7733 StmtResult Res = getDerived().TransformStmt(ReturnStmt);
7734 if (Res.isInvalid())
7735 return StmtError();
7736 Builder.ReturnStmt = Res.get();
7737 }
7738 }
7739
7740 return getDerived().RebuildCoroutineBodyStmt(Builder);
7741}
7742
7743template<typename Derived>
7744StmtResult
7745TreeTransform<Derived>::TransformCoreturnStmt(CoreturnStmt *S) {
7746 ExprResult Result = getDerived().TransformInitializer(S->getOperand(),
7747 /*NotCopyInit*/false);
7748 if (Result.isInvalid())
7749 return StmtError();
7750
7751 // Always rebuild; we don't know if this needs to be injected into a new
7752 // context or if the promise type has changed.
7753 return getDerived().RebuildCoreturnStmt(S->getKeywordLoc(), Result.get(),
7754 S->isImplicit());
7755}
7756
7757template<typename Derived>
7758ExprResult
7759TreeTransform<Derived>::TransformCoawaitExpr(CoawaitExpr *E) {
7760 ExprResult Result = getDerived().TransformInitializer(E->getOperand(),
7761 /*NotCopyInit*/false);
7762 if (Result.isInvalid())
7763 return ExprError();
7764
7765 // Always rebuild; we don't know if this needs to be injected into a new
7766 // context or if the promise type has changed.
7767 return getDerived().RebuildCoawaitExpr(E->getKeywordLoc(), Result.get(),
7768 E->isImplicit());
7769}
7770
7771template <typename Derived>
7772ExprResult
7773TreeTransform<Derived>::TransformDependentCoawaitExpr(DependentCoawaitExpr *E) {
7774 ExprResult OperandResult = getDerived().TransformInitializer(E->getOperand(),
7775 /*NotCopyInit*/ false);
7776 if (OperandResult.isInvalid())
7777 return ExprError();
7778
7779 ExprResult LookupResult = getDerived().TransformUnresolvedLookupExpr(
7780 E->getOperatorCoawaitLookup());
7781
7782 if (LookupResult.isInvalid())
7783 return ExprError();
7784
7785 // Always rebuild; we don't know if this needs to be injected into a new
7786 // context or if the promise type has changed.
7787 return getDerived().RebuildDependentCoawaitExpr(
7788 E->getKeywordLoc(), OperandResult.get(),
7789 cast<UnresolvedLookupExpr>(LookupResult.get()));
7790}
7791
7792template<typename Derived>
7793ExprResult
7794TreeTransform<Derived>::TransformCoyieldExpr(CoyieldExpr *E) {
7795 ExprResult Result = getDerived().TransformInitializer(E->getOperand(),
7796 /*NotCopyInit*/false);
7797 if (Result.isInvalid())
7798 return ExprError();
7799
7800 // Always rebuild; we don't know if this needs to be injected into a new
7801 // context or if the promise type has changed.
7802 return getDerived().RebuildCoyieldExpr(E->getKeywordLoc(), Result.get());
7803}
7804
7805// Objective-C Statements.
7806
7807template<typename Derived>
7808StmtResult
7809TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) {
7810 // Transform the body of the @try.
7811 StmtResult TryBody = getDerived().TransformStmt(S->getTryBody());
7812 if (TryBody.isInvalid())
7813 return StmtError();
7814
7815 // Transform the @catch statements (if present).
7816 bool AnyCatchChanged = false;
7817 SmallVector<Stmt*, 8> CatchStmts;
7818 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) {
7819 StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I));
7820 if (Catch.isInvalid())
7821 return StmtError();
7822 if (Catch.get() != S->getCatchStmt(I))
7823 AnyCatchChanged = true;
7824 CatchStmts.push_back(Catch.get());
7825 }
7826
7827 // Transform the @finally statement (if present).
7828 StmtResult Finally;
7829 if (S->getFinallyStmt()) {
7830 Finally = getDerived().TransformStmt(S->getFinallyStmt());
7831 if (Finally.isInvalid())
7832 return StmtError();
7833 }
7834
7835 // If nothing changed, just retain this statement.
7836 if (!getDerived().AlwaysRebuild() &&
7837 TryBody.get() == S->getTryBody() &&
7838 !AnyCatchChanged &&
7839 Finally.get() == S->getFinallyStmt())
7840 return S;
7841
7842 // Build a new statement.
7843 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(),
7844 CatchStmts, Finally.get());
7845}
7846
7847template<typename Derived>
7848StmtResult
7849TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) {
7850 // Transform the @catch parameter, if there is one.
7851 VarDecl *Var = nullptr;
7852 if (VarDecl *FromVar = S->getCatchParamDecl()) {
7853 TypeSourceInfo *TSInfo = nullptr;
7854 if (FromVar->getTypeSourceInfo()) {
7855 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo());
7856 if (!TSInfo)
7857 return StmtError();
7858 }
7859
7860 QualType T;
7861 if (TSInfo)
7862 T = TSInfo->getType();
7863 else {
7864 T = getDerived().TransformType(FromVar->getType());
7865 if (T.isNull())
7866 return StmtError();
7867 }
7868
7869 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T);
7870 if (!Var)
7871 return StmtError();
7872 }
7873
7874 StmtResult Body = getDerived().TransformStmt(S->getCatchBody());
7875 if (Body.isInvalid())
7876 return StmtError();
7877
7878 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(),
7879 S->getRParenLoc(),
7880 Var, Body.get());
7881}
7882
7883template<typename Derived>
7884StmtResult
7885TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
7886 // Transform the body.
7887 StmtResult Body = getDerived().TransformStmt(S->getFinallyBody());
7888 if (Body.isInvalid())
7889 return StmtError();
7890
7891 // If nothing changed, just retain this statement.
7892 if (!getDerived().AlwaysRebuild() &&
7893 Body.get() == S->getFinallyBody())
7894 return S;
7895
7896 // Build a new statement.
7897 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(),
7898 Body.get());
7899}
7900
7901template<typename Derived>
7902StmtResult
7903TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) {
7904 ExprResult Operand;
7905 if (S->getThrowExpr()) {
7906 Operand = getDerived().TransformExpr(S->getThrowExpr());
7907 if (Operand.isInvalid())
7908 return StmtError();
7909 }
7910
7911 if (!getDerived().AlwaysRebuild() &&
7912 Operand.get() == S->getThrowExpr())
7913 return S;
7914
7915 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get());
7916}
7917
7918template<typename Derived>
7919StmtResult
7920TreeTransform<Derived>::TransformObjCAtSynchronizedStmt(
7921 ObjCAtSynchronizedStmt *S) {
7922 // Transform the object we are locking.
7923 ExprResult Object = getDerived().TransformExpr(S->getSynchExpr());
7924 if (Object.isInvalid())
7925 return StmtError();
7926 Object =
7927 getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(),
7928 Object.get());
7929 if (Object.isInvalid())
7930 return StmtError();
7931
7932 // Transform the body.
7933 StmtResult Body = getDerived().TransformStmt(S->getSynchBody());
7934 if (Body.isInvalid())
7935 return StmtError();
7936
7937 // If nothing change, just retain the current statement.
7938 if (!getDerived().AlwaysRebuild() &&
7939 Object.get() == S->getSynchExpr() &&
7940 Body.get() == S->getSynchBody())
7941 return S;
7942
7943 // Build a new statement.
7944 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(),
7945 Object.get(), Body.get());
7946}
7947
7948template<typename Derived>
7949StmtResult
7950TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt(
7951 ObjCAutoreleasePoolStmt *S) {
7952 // Transform the body.
7953 StmtResult Body = getDerived().TransformStmt(S->getSubStmt());
7954 if (Body.isInvalid())
7955 return StmtError();
7956
7957 // If nothing changed, just retain this statement.
7958 if (!getDerived().AlwaysRebuild() &&
7959 Body.get() == S->getSubStmt())
7960 return S;
7961
7962 // Build a new statement.
7963 return getDerived().RebuildObjCAutoreleasePoolStmt(
7964 S->getAtLoc(), Body.get());
7965}
7966
7967template<typename Derived>
7968StmtResult
7969TreeTransform<Derived>::TransformObjCForCollectionStmt(
7970 ObjCForCollectionStmt *S) {
7971 // Transform the element statement.
7972 StmtResult Element =
7973 getDerived().TransformStmt(S->getElement(), SDK_NotDiscarded);
7974 if (Element.isInvalid())
7975 return StmtError();
7976
7977 // Transform the collection expression.
7978 ExprResult Collection = getDerived().TransformExpr(S->getCollection());
7979 if (Collection.isInvalid())
7980 return StmtError();
7981
7982 // Transform the body.
7983 StmtResult Body = getDerived().TransformStmt(S->getBody());
7984 if (Body.isInvalid())
7985 return StmtError();
7986
7987 // If nothing changed, just retain this statement.
7988 if (!getDerived().AlwaysRebuild() &&
7989 Element.get() == S->getElement() &&
7990 Collection.get() == S->getCollection() &&
7991 Body.get() == S->getBody())
7992 return S;
7993
7994 // Build a new statement.
7995 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(),
7996 Element.get(),
7997 Collection.get(),
7998 S->getRParenLoc(),
7999 Body.get());
8000}
8001
8002template <typename Derived>
8003StmtResult TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) {
8004 // Transform the exception declaration, if any.
8005 VarDecl *Var = nullptr;
8006 if (VarDecl *ExceptionDecl = S->getExceptionDecl()) {
8007 TypeSourceInfo *T =
8008 getDerived().TransformType(ExceptionDecl->getTypeSourceInfo());
8009 if (!T)
8010 return StmtError();
8011
8012 Var = getDerived().RebuildExceptionDecl(
8013 ExceptionDecl, T, ExceptionDecl->getInnerLocStart(),
8014 ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier());
8015 if (!Var || Var->isInvalidDecl())
8016 return StmtError();
8017 }
8018
8019 // Transform the actual exception handler.
8020 StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
8021 if (Handler.isInvalid())
8022 return StmtError();
8023
8024 if (!getDerived().AlwaysRebuild() && !Var &&
8025 Handler.get() == S->getHandlerBlock())
8026 return S;
8027
8028 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, Handler.get());
8029}
8030
8031template <typename Derived>
8032StmtResult TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) {
8033 // Transform the try block itself.
8034 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
8035 if (TryBlock.isInvalid())
8036 return StmtError();
8037
8038 // Transform the handlers.
8039 bool HandlerChanged = false;
8040 SmallVector<Stmt *, 8> Handlers;
8041 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) {
8042 StmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(I));
8043 if (Handler.isInvalid())
8044 return StmtError();
8045
8046 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I);
8047 Handlers.push_back(Handler.getAs<Stmt>());
8048 }
8049
8050 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
8051 !HandlerChanged)
8052 return S;
8053
8054 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(),
8055 Handlers);
8056}
8057
8058template<typename Derived>
8059StmtResult
8060TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) {
8061 StmtResult Init =
8062 S->getInit() ? getDerived().TransformStmt(S->getInit()) : StmtResult();
8063 if (Init.isInvalid())
8064 return StmtError();
8065
8066 StmtResult Range = getDerived().TransformStmt(S->getRangeStmt());
8067 if (Range.isInvalid())
8068 return StmtError();
8069
8070 StmtResult Begin = getDerived().TransformStmt(S->getBeginStmt());
8071 if (Begin.isInvalid())
8072 return StmtError();
8073 StmtResult End = getDerived().TransformStmt(S->getEndStmt());
8074 if (End.isInvalid())
8075 return StmtError();
8076
8077 ExprResult Cond = getDerived().TransformExpr(S->getCond());
8078 if (Cond.isInvalid())
8079 return StmtError();
8080 if (Cond.get())
8081 Cond = SemaRef.CheckBooleanCondition(S->getColonLoc(), Cond.get());
8082 if (Cond.isInvalid())
8083 return StmtError();
8084 if (Cond.get())
8085 Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.get());
8086
8087 ExprResult Inc = getDerived().TransformExpr(S->getInc());
8088 if (Inc.isInvalid())
8089 return StmtError();
8090 if (Inc.get())
8091 Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.get());
8092
8093 StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt());
8094 if (LoopVar.isInvalid())
8095 return StmtError();
8096
8097 StmtResult NewStmt = S;
8098 if (getDerived().AlwaysRebuild() ||
8099 Init.get() != S->getInit() ||
8100 Range.get() != S->getRangeStmt() ||
8101 Begin.get() != S->getBeginStmt() ||
8102 End.get() != S->getEndStmt() ||
8103 Cond.get() != S->getCond() ||
8104 Inc.get() != S->getInc() ||
8105 LoopVar.get() != S->getLoopVarStmt()) {
8106 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
8107 S->getCoawaitLoc(), Init.get(),
8108 S->getColonLoc(), Range.get(),
8109 Begin.get(), End.get(),
8110 Cond.get(),
8111 Inc.get(), LoopVar.get(),
8112 S->getRParenLoc());
8113 if (NewStmt.isInvalid() && LoopVar.get() != S->getLoopVarStmt()) {
8114 // Might not have attached any initializer to the loop variable.
8115 getSema().ActOnInitializerError(
8116 cast<DeclStmt>(LoopVar.get())->getSingleDecl());
8117 return StmtError();
8118 }
8119 }
8120
8121 StmtResult Body = getDerived().TransformStmt(S->getBody());
8122 if (Body.isInvalid())
8123 return StmtError();
8124
8125 // Body has changed but we didn't rebuild the for-range statement. Rebuild
8126 // it now so we have a new statement to attach the body to.
8127 if (Body.get() != S->getBody() && NewStmt.get() == S) {
8128 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(),
8129 S->getCoawaitLoc(), Init.get(),
8130 S->getColonLoc(), Range.get(),
8131 Begin.get(), End.get(),
8132 Cond.get(),
8133 Inc.get(), LoopVar.get(),
8134 S->getRParenLoc());
8135 if (NewStmt.isInvalid())
8136 return StmtError();
8137 }
8138
8139 if (NewStmt.get() == S)
8140 return S;
8141
8142 return FinishCXXForRangeStmt(NewStmt.get(), Body.get());
8143}
8144
8145template<typename Derived>
8146StmtResult
8147TreeTransform<Derived>::TransformMSDependentExistsStmt(
8148 MSDependentExistsStmt *S) {
8149 // Transform the nested-name-specifier, if any.
8150 NestedNameSpecifierLoc QualifierLoc;
8151 if (S->getQualifierLoc()) {
8152 QualifierLoc
8153 = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc());
8154 if (!QualifierLoc)
8155 return StmtError();
8156 }
8157
8158 // Transform the declaration name.
8159 DeclarationNameInfo NameInfo = S->getNameInfo();
8160 if (NameInfo.getName()) {
8161 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
8162 if (!NameInfo.getName())
8163 return StmtError();
8164 }
8165
8166 // Check whether anything changed.
8167 if (!getDerived().AlwaysRebuild() &&
8168 QualifierLoc == S->getQualifierLoc() &&
8169 NameInfo.getName() == S->getNameInfo().getName())
8170 return S;
8171
8172 // Determine whether this name exists, if we can.
8173 CXXScopeSpec SS;
8174 SS.Adopt(QualifierLoc);
8175 bool Dependent = false;
8176 switch (getSema().CheckMicrosoftIfExistsSymbol(/*S=*/nullptr, SS, NameInfo)) {
8177 case Sema::IER_Exists:
8178 if (S->isIfExists())
8179 break;
8180
8181 return new (getSema().Context) NullStmt(S->getKeywordLoc());
8182
8183 case Sema::IER_DoesNotExist:
8184 if (S->isIfNotExists())
8185 break;
8186
8187 return new (getSema().Context) NullStmt(S->getKeywordLoc());
8188
8189 case Sema::IER_Dependent:
8190 Dependent = true;
8191 break;
8192
8193 case Sema::IER_Error:
8194 return StmtError();
8195 }
8196
8197 // We need to continue with the instantiation, so do so now.
8198 StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt());
8199 if (SubStmt.isInvalid())
8200 return StmtError();
8201
8202 // If we have resolved the name, just transform to the substatement.
8203 if (!Dependent)
8204 return SubStmt;
8205
8206 // The name is still dependent, so build a dependent expression again.
8207 return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(),
8208 S->isIfExists(),
8209 QualifierLoc,
8210 NameInfo,
8211 SubStmt.get());
8212}
8213
8214template<typename Derived>
8215ExprResult
8216TreeTransform<Derived>::TransformMSPropertyRefExpr(MSPropertyRefExpr *E) {
8217 NestedNameSpecifierLoc QualifierLoc;
8218 if (E->getQualifierLoc()) {
8219 QualifierLoc
8220 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
8221 if (!QualifierLoc)
8222 return ExprError();
8223 }
8224
8225 MSPropertyDecl *PD = cast_or_null<MSPropertyDecl>(
8226 getDerived().TransformDecl(E->getMemberLoc(), E->getPropertyDecl()));
8227 if (!PD)
8228 return ExprError();
8229
8230 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
8231 if (Base.isInvalid())
8232 return ExprError();
8233
8234 return new (SemaRef.getASTContext())
8235 MSPropertyRefExpr(Base.get(), PD, E->isArrow(),
8236 SemaRef.getASTContext().PseudoObjectTy, VK_LValue,
8237 QualifierLoc, E->getMemberLoc());
8238}
8239
8240template <typename Derived>
8241ExprResult TreeTransform<Derived>::TransformMSPropertySubscriptExpr(
8242 MSPropertySubscriptExpr *E) {
8243 auto BaseRes = getDerived().TransformExpr(E->getBase());
8244 if (BaseRes.isInvalid())
8245 return ExprError();
8246 auto IdxRes = getDerived().TransformExpr(E->getIdx());
8247 if (IdxRes.isInvalid())
8248 return ExprError();
8249
8250 if (!getDerived().AlwaysRebuild() &&
8251 BaseRes.get() == E->getBase() &&
8252 IdxRes.get() == E->getIdx())
8253 return E;
8254
8255 return getDerived().RebuildArraySubscriptExpr(
8256 BaseRes.get(), SourceLocation(), IdxRes.get(), E->getRBracketLoc());
8257}
8258
8259template <typename Derived>
8260StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) {
8261 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
8262 if (TryBlock.isInvalid())
8263 return StmtError();
8264
8265 StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler());
8266 if (Handler.isInvalid())
8267 return StmtError();
8268
8269 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
8270 Handler.get() == S->getHandler())
8271 return S;
8272
8273 return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(),
8274 TryBlock.get(), Handler.get());
8275}
8276
8277template <typename Derived>
8278StmtResult TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) {
8279 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
8280 if (Block.isInvalid())
8281 return StmtError();
8282
8283 return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.get());
8284}
8285
8286template <typename Derived>
8287StmtResult TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) {
8288 ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr());
8289 if (FilterExpr.isInvalid())
8290 return StmtError();
8291
8292 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
8293 if (Block.isInvalid())
8294 return StmtError();
8295
8296 return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(),
8297 Block.get());
8298}
8299
8300template <typename Derived>
8301StmtResult TreeTransform<Derived>::TransformSEHHandler(Stmt *Handler) {
8302 if (isa<SEHFinallyStmt>(Handler))
8303 return getDerived().TransformSEHFinallyStmt(cast<SEHFinallyStmt>(Handler));
8304 else
8305 return getDerived().TransformSEHExceptStmt(cast<SEHExceptStmt>(Handler));
8306}
8307
8308template<typename Derived>
8309StmtResult
8310TreeTransform<Derived>::TransformSEHLeaveStmt(SEHLeaveStmt *S) {
8311 return S;
8312}
8313
8314//===----------------------------------------------------------------------===//
8315// OpenMP directive transformation
8316//===----------------------------------------------------------------------===//
8317template <typename Derived>
8318StmtResult TreeTransform<Derived>::TransformOMPExecutableDirective(
8319 OMPExecutableDirective *D) {
8320
8321 // Transform the clauses
8322 llvm::SmallVector<OMPClause *, 16> TClauses;
8323 ArrayRef<OMPClause *> Clauses = D->clauses();
8324 TClauses.reserve(Clauses.size());
8325 for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
8326 I != E; ++I) {
8327 if (*I) {
8328 getDerived().getSema().StartOpenMPClause((*I)->getClauseKind());
8329 OMPClause *Clause = getDerived().TransformOMPClause(*I);
8330 getDerived().getSema().EndOpenMPClause();
8331 if (Clause)
8332 TClauses.push_back(Clause);
8333 } else {
8334 TClauses.push_back(nullptr);
8335 }
8336 }
8337 StmtResult AssociatedStmt;
8338 if (D->hasAssociatedStmt() && D->getAssociatedStmt()) {
8339 getDerived().getSema().ActOnOpenMPRegionStart(D->getDirectiveKind(),
8340 /*CurScope=*/nullptr);
8341 StmtResult Body;
8342 {
8343 Sema::CompoundScopeRAII CompoundScope(getSema());
8344 Stmt *CS;
8345 if (D->getDirectiveKind() == OMPD_atomic ||
8346 D->getDirectiveKind() == OMPD_critical ||
8347 D->getDirectiveKind() == OMPD_section ||
8348 D->getDirectiveKind() == OMPD_master)
8349 CS = D->getAssociatedStmt();
8350 else
8351 CS = D->getInnermostCapturedStmt()->getCapturedStmt();
8352 Body = getDerived().TransformStmt(CS);
8353 }
8354 AssociatedStmt =
8355 getDerived().getSema().ActOnOpenMPRegionEnd(Body, TClauses);
8356 if (AssociatedStmt.isInvalid()) {
8357 return StmtError();
8358 }
8359 }
8360 if (TClauses.size() != Clauses.size()) {
8361 return StmtError();
8362 }
8363
8364 // Transform directive name for 'omp critical' directive.
8365 DeclarationNameInfo DirName;
8366 if (D->getDirectiveKind() == OMPD_critical) {
8367 DirName = cast<OMPCriticalDirective>(D)->getDirectiveName();
8368 DirName = getDerived().TransformDeclarationNameInfo(DirName);
8369 }
8370 OpenMPDirectiveKind CancelRegion = OMPD_unknown;
8371 if (D->getDirectiveKind() == OMPD_cancellation_point) {
8372 CancelRegion = cast<OMPCancellationPointDirective>(D)->getCancelRegion();
8373 } else if (D->getDirectiveKind() == OMPD_cancel) {
8374 CancelRegion = cast<OMPCancelDirective>(D)->getCancelRegion();
8375 }
8376
8377 return getDerived().RebuildOMPExecutableDirective(
8378 D->getDirectiveKind(), DirName, CancelRegion, TClauses,
8379 AssociatedStmt.get(), D->getBeginLoc(), D->getEndLoc());
8380}
8381
8382template <typename Derived>
8383StmtResult
8384TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *D) {
8385 DeclarationNameInfo DirName;
8386 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel, DirName, nullptr,
8387 D->getBeginLoc());
8388 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8389 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8390 return Res;
8391}
8392
8393template <typename Derived>
8394StmtResult
8395TreeTransform<Derived>::TransformOMPSimdDirective(OMPSimdDirective *D) {
8396 DeclarationNameInfo DirName;
8397 getDerived().getSema().StartOpenMPDSABlock(OMPD_simd, DirName, nullptr,
8398 D->getBeginLoc());
8399 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8400 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8401 return Res;
8402}
8403
8404template <typename Derived>
8405StmtResult
8406TreeTransform<Derived>::TransformOMPForDirective(OMPForDirective *D) {
8407 DeclarationNameInfo DirName;
8408 getDerived().getSema().StartOpenMPDSABlock(OMPD_for, DirName, nullptr,
8409 D->getBeginLoc());
8410 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8411 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8412 return Res;
8413}
8414
8415template <typename Derived>
8416StmtResult
8417TreeTransform<Derived>::TransformOMPForSimdDirective(OMPForSimdDirective *D) {
8418 DeclarationNameInfo DirName;
8419 getDerived().getSema().StartOpenMPDSABlock(OMPD_for_simd, DirName, nullptr,
8420 D->getBeginLoc());
8421 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8422 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8423 return Res;
8424}
8425
8426template <typename Derived>
8427StmtResult
8428TreeTransform<Derived>::TransformOMPSectionsDirective(OMPSectionsDirective *D) {
8429 DeclarationNameInfo DirName;
8430 getDerived().getSema().StartOpenMPDSABlock(OMPD_sections, DirName, nullptr,
8431 D->getBeginLoc());
8432 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8433 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8434 return Res;
8435}
8436
8437template <typename Derived>
8438StmtResult
8439TreeTransform<Derived>::TransformOMPSectionDirective(OMPSectionDirective *D) {
8440 DeclarationNameInfo DirName;
8441 getDerived().getSema().StartOpenMPDSABlock(OMPD_section, DirName, nullptr,
8442 D->getBeginLoc());
8443 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8444 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8445 return Res;
8446}
8447
8448template <typename Derived>
8449StmtResult
8450TreeTransform<Derived>::TransformOMPSingleDirective(OMPSingleDirective *D) {
8451 DeclarationNameInfo DirName;
8452 getDerived().getSema().StartOpenMPDSABlock(OMPD_single, DirName, nullptr,
8453 D->getBeginLoc());
8454 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8455 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8456 return Res;
8457}
8458
8459template <typename Derived>
8460StmtResult
8461TreeTransform<Derived>::TransformOMPMasterDirective(OMPMasterDirective *D) {
8462 DeclarationNameInfo DirName;
8463 getDerived().getSema().StartOpenMPDSABlock(OMPD_master, DirName, nullptr,
8464 D->getBeginLoc());
8465 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8466 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8467 return Res;
8468}
8469
8470template <typename Derived>
8471StmtResult
8472TreeTransform<Derived>::TransformOMPCriticalDirective(OMPCriticalDirective *D) {
8473 getDerived().getSema().StartOpenMPDSABlock(
8474 OMPD_critical, D->getDirectiveName(), nullptr, D->getBeginLoc());
8475 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8476 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8477 return Res;
8478}
8479
8480template <typename Derived>
8481StmtResult TreeTransform<Derived>::TransformOMPParallelForDirective(
8482 OMPParallelForDirective *D) {
8483 DeclarationNameInfo DirName;
8484 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for, DirName,
8485 nullptr, D->getBeginLoc());
8486 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8487 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8488 return Res;
8489}
8490
8491template <typename Derived>
8492StmtResult TreeTransform<Derived>::TransformOMPParallelForSimdDirective(
8493 OMPParallelForSimdDirective *D) {
8494 DeclarationNameInfo DirName;
8495 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for_simd, DirName,
8496 nullptr, D->getBeginLoc());
8497 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8498 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8499 return Res;
8500}
8501
8502template <typename Derived>
8503StmtResult TreeTransform<Derived>::TransformOMPParallelMasterDirective(
8504 OMPParallelMasterDirective *D) {
8505 DeclarationNameInfo DirName;
8506 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_master, DirName,
8507 nullptr, D->getBeginLoc());
8508 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8509 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8510 return Res;
8511}
8512
8513template <typename Derived>
8514StmtResult TreeTransform<Derived>::TransformOMPParallelSectionsDirective(
8515 OMPParallelSectionsDirective *D) {
8516 DeclarationNameInfo DirName;
8517 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_sections, DirName,
8518 nullptr, D->getBeginLoc());
8519 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8520 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8521 return Res;
8522}
8523
8524template <typename Derived>
8525StmtResult
8526TreeTransform<Derived>::TransformOMPTaskDirective(OMPTaskDirective *D) {
8527 DeclarationNameInfo DirName;
8528 getDerived().getSema().StartOpenMPDSABlock(OMPD_task, DirName, nullptr,
8529 D->getBeginLoc());
8530 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8531 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8532 return Res;
8533}
8534
8535template <typename Derived>
8536StmtResult TreeTransform<Derived>::TransformOMPTaskyieldDirective(
8537 OMPTaskyieldDirective *D) {
8538 DeclarationNameInfo DirName;
8539 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskyield, DirName, nullptr,
8540 D->getBeginLoc());
8541 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8542 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8543 return Res;
8544}
8545
8546template <typename Derived>
8547StmtResult
8548TreeTransform<Derived>::TransformOMPBarrierDirective(OMPBarrierDirective *D) {
8549 DeclarationNameInfo DirName;
8550 getDerived().getSema().StartOpenMPDSABlock(OMPD_barrier, DirName, nullptr,
8551 D->getBeginLoc());
8552 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8553 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8554 return Res;
8555}
8556
8557template <typename Derived>
8558StmtResult
8559TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
8560 DeclarationNameInfo DirName;
8561 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskwait, DirName, nullptr,
8562 D->getBeginLoc());
8563 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8564 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8565 return Res;
8566}
8567
8568template <typename Derived>
8569StmtResult TreeTransform<Derived>::TransformOMPTaskgroupDirective(
8570 OMPTaskgroupDirective *D) {
8571 DeclarationNameInfo DirName;
8572 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskgroup, DirName, nullptr,
8573 D->getBeginLoc());
8574 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8575 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8576 return Res;
8577}
8578
8579template <typename Derived>
8580StmtResult
8581TreeTransform<Derived>::TransformOMPFlushDirective(OMPFlushDirective *D) {
8582 DeclarationNameInfo DirName;
8583 getDerived().getSema().StartOpenMPDSABlock(OMPD_flush, DirName, nullptr,
8584 D->getBeginLoc());
8585 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8586 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8587 return Res;
8588}
8589
8590template <typename Derived>
8591StmtResult
8592TreeTransform<Derived>::TransformOMPDepobjDirective(OMPDepobjDirective *D) {
8593 DeclarationNameInfo DirName;
8594 getDerived().getSema().StartOpenMPDSABlock(OMPD_depobj, DirName, nullptr,
8595 D->getBeginLoc());
8596 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8597 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8598 return Res;
8599}
8600
8601template <typename Derived>
8602StmtResult
8603TreeTransform<Derived>::TransformOMPScanDirective(OMPScanDirective *D) {
8604 DeclarationNameInfo DirName;
8605 getDerived().getSema().StartOpenMPDSABlock(OMPD_scan, DirName, nullptr,
8606 D->getBeginLoc());
8607 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8608 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8609 return Res;
8610}
8611
8612template <typename Derived>
8613StmtResult
8614TreeTransform<Derived>::TransformOMPOrderedDirective(OMPOrderedDirective *D) {
8615 DeclarationNameInfo DirName;
8616 getDerived().getSema().StartOpenMPDSABlock(OMPD_ordered, DirName, nullptr,
8617 D->getBeginLoc());
8618 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8619 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8620 return Res;
8621}
8622
8623template <typename Derived>
8624StmtResult
8625TreeTransform<Derived>::TransformOMPAtomicDirective(OMPAtomicDirective *D) {
8626 DeclarationNameInfo DirName;
8627 getDerived().getSema().StartOpenMPDSABlock(OMPD_atomic, DirName, nullptr,
8628 D->getBeginLoc());
8629 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8630 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8631 return Res;
8632}
8633
8634template <typename Derived>
8635StmtResult
8636TreeTransform<Derived>::TransformOMPTargetDirective(OMPTargetDirective *D) {
8637 DeclarationNameInfo DirName;
8638 getDerived().getSema().StartOpenMPDSABlock(OMPD_target, DirName, nullptr,
8639 D->getBeginLoc());
8640 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8641 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8642 return Res;
8643}
8644
8645template <typename Derived>
8646StmtResult TreeTransform<Derived>::TransformOMPTargetDataDirective(
8647 OMPTargetDataDirective *D) {
8648 DeclarationNameInfo DirName;
8649 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_data, DirName, nullptr,
8650 D->getBeginLoc());
8651 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8652 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8653 return Res;
8654}
8655
8656template <typename Derived>
8657StmtResult TreeTransform<Derived>::TransformOMPTargetEnterDataDirective(
8658 OMPTargetEnterDataDirective *D) {
8659 DeclarationNameInfo DirName;
8660 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_enter_data, DirName,
8661 nullptr, D->getBeginLoc());
8662 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8663 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8664 return Res;
8665}
8666
8667template <typename Derived>
8668StmtResult TreeTransform<Derived>::TransformOMPTargetExitDataDirective(
8669 OMPTargetExitDataDirective *D) {
8670 DeclarationNameInfo DirName;
8671 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_exit_data, DirName,
8672 nullptr, D->getBeginLoc());
8673 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8674 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8675 return Res;
8676}
8677
8678template <typename Derived>
8679StmtResult TreeTransform<Derived>::TransformOMPTargetParallelDirective(
8680 OMPTargetParallelDirective *D) {
8681 DeclarationNameInfo DirName;
8682 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel, DirName,
8683 nullptr, D->getBeginLoc());
8684 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8685 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8686 return Res;
8687}
8688
8689template <typename Derived>
8690StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForDirective(
8691 OMPTargetParallelForDirective *D) {
8692 DeclarationNameInfo DirName;
8693 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel_for, DirName,
8694 nullptr, D->getBeginLoc());
8695 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8696 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8697 return Res;
8698}
8699
8700template <typename Derived>
8701StmtResult TreeTransform<Derived>::TransformOMPTargetUpdateDirective(
8702 OMPTargetUpdateDirective *D) {
8703 DeclarationNameInfo DirName;
8704 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_update, DirName,
8705 nullptr, D->getBeginLoc());
8706 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8707 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8708 return Res;
8709}
8710
8711template <typename Derived>
8712StmtResult
8713TreeTransform<Derived>::TransformOMPTeamsDirective(OMPTeamsDirective *D) {
8714 DeclarationNameInfo DirName;
8715 getDerived().getSema().StartOpenMPDSABlock(OMPD_teams, DirName, nullptr,
8716 D->getBeginLoc());
8717 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8718 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8719 return Res;
8720}
8721
8722template <typename Derived>
8723StmtResult TreeTransform<Derived>::TransformOMPCancellationPointDirective(
8724 OMPCancellationPointDirective *D) {
8725 DeclarationNameInfo DirName;
8726 getDerived().getSema().StartOpenMPDSABlock(OMPD_cancellation_point, DirName,
8727 nullptr, D->getBeginLoc());
8728 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8729 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8730 return Res;
8731}
8732
8733template <typename Derived>
8734StmtResult
8735TreeTransform<Derived>::TransformOMPCancelDirective(OMPCancelDirective *D) {
8736 DeclarationNameInfo DirName;
8737 getDerived().getSema().StartOpenMPDSABlock(OMPD_cancel, DirName, nullptr,
8738 D->getBeginLoc());
8739 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8740 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8741 return Res;
8742}
8743
8744template <typename Derived>
8745StmtResult
8746TreeTransform<Derived>::TransformOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
8747 DeclarationNameInfo DirName;
8748 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskloop, DirName, nullptr,
8749 D->getBeginLoc());
8750 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8751 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8752 return Res;
8753}
8754
8755template <typename Derived>
8756StmtResult TreeTransform<Derived>::TransformOMPTaskLoopSimdDirective(
8757 OMPTaskLoopSimdDirective *D) {
8758 DeclarationNameInfo DirName;
8759 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskloop_simd, DirName,
8760 nullptr, D->getBeginLoc());
8761 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8762 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8763 return Res;
8764}
8765
8766template <typename Derived>
8767StmtResult TreeTransform<Derived>::TransformOMPMasterTaskLoopDirective(
8768 OMPMasterTaskLoopDirective *D) {
8769 DeclarationNameInfo DirName;
8770 getDerived().getSema().StartOpenMPDSABlock(OMPD_master_taskloop, DirName,
8771 nullptr, D->getBeginLoc());
8772 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8773 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8774 return Res;
8775}
8776
8777template <typename Derived>
8778StmtResult TreeTransform<Derived>::TransformOMPMasterTaskLoopSimdDirective(
8779 OMPMasterTaskLoopSimdDirective *D) {
8780 DeclarationNameInfo DirName;
8781 getDerived().getSema().StartOpenMPDSABlock(OMPD_master_taskloop_simd, DirName,
8782 nullptr, D->getBeginLoc());
8783 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8784 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8785 return Res;
8786}
8787
8788template <typename Derived>
8789StmtResult TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopDirective(
8790 OMPParallelMasterTaskLoopDirective *D) {
8791 DeclarationNameInfo DirName;
8792 getDerived().getSema().StartOpenMPDSABlock(
8793 OMPD_parallel_master_taskloop, DirName, nullptr, D->getBeginLoc());
8794 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8795 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8796 return Res;
8797}
8798
8799template <typename Derived>
8800StmtResult
8801TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopSimdDirective(
8802 OMPParallelMasterTaskLoopSimdDirective *D) {
8803 DeclarationNameInfo DirName;
8804 getDerived().getSema().StartOpenMPDSABlock(
8805 OMPD_parallel_master_taskloop_simd, DirName, nullptr, D->getBeginLoc());
8806 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8807 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8808 return Res;
8809}
8810
8811template <typename Derived>
8812StmtResult TreeTransform<Derived>::TransformOMPDistributeDirective(
8813 OMPDistributeDirective *D) {
8814 DeclarationNameInfo DirName;
8815 getDerived().getSema().StartOpenMPDSABlock(OMPD_distribute, DirName, nullptr,
8816 D->getBeginLoc());
8817 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8818 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8819 return Res;
8820}
8821
8822template <typename Derived>
8823StmtResult TreeTransform<Derived>::TransformOMPDistributeParallelForDirective(
8824 OMPDistributeParallelForDirective *D) {
8825 DeclarationNameInfo DirName;
8826 getDerived().getSema().StartOpenMPDSABlock(
8827 OMPD_distribute_parallel_for, DirName, nullptr, D->getBeginLoc());
8828 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8829 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8830 return Res;
8831}
8832
8833template <typename Derived>
8834StmtResult
8835TreeTransform<Derived>::TransformOMPDistributeParallelForSimdDirective(
8836 OMPDistributeParallelForSimdDirective *D) {
8837 DeclarationNameInfo DirName;
8838 getDerived().getSema().StartOpenMPDSABlock(
8839 OMPD_distribute_parallel_for_simd, DirName, nullptr, D->getBeginLoc());
8840 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8841 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8842 return Res;
8843}
8844
8845template <typename Derived>
8846StmtResult TreeTransform<Derived>::TransformOMPDistributeSimdDirective(
8847 OMPDistributeSimdDirective *D) {
8848 DeclarationNameInfo DirName;
8849 getDerived().getSema().StartOpenMPDSABlock(OMPD_distribute_simd, DirName,
8850 nullptr, D->getBeginLoc());
8851 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8852 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8853 return Res;
8854}
8855
8856template <typename Derived>
8857StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForSimdDirective(
8858 OMPTargetParallelForSimdDirective *D) {
8859 DeclarationNameInfo DirName;
8860 getDerived().getSema().StartOpenMPDSABlock(
8861 OMPD_target_parallel_for_simd, DirName, nullptr, D->getBeginLoc());
8862 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8863 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8864 return Res;
8865}
8866
8867template <typename Derived>
8868StmtResult TreeTransform<Derived>::TransformOMPTargetSimdDirective(
8869 OMPTargetSimdDirective *D) {
8870 DeclarationNameInfo DirName;
8871 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_simd, DirName, nullptr,
8872 D->getBeginLoc());
8873 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8874 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8875 return Res;
8876}
8877
8878template <typename Derived>
8879StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeDirective(
8880 OMPTeamsDistributeDirective *D) {
8881 DeclarationNameInfo DirName;
8882 getDerived().getSema().StartOpenMPDSABlock(OMPD_teams_distribute, DirName,
8883 nullptr, D->getBeginLoc());
8884 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8885 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8886 return Res;
8887}
8888
8889template <typename Derived>
8890StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeSimdDirective(
8891 OMPTeamsDistributeSimdDirective *D) {
8892 DeclarationNameInfo DirName;
8893 getDerived().getSema().StartOpenMPDSABlock(
8894 OMPD_teams_distribute_simd, DirName, nullptr, D->getBeginLoc());
8895 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8896 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8897 return Res;
8898}
8899
8900template <typename Derived>
8901StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForSimdDirective(
8902 OMPTeamsDistributeParallelForSimdDirective *D) {
8903 DeclarationNameInfo DirName;
8904 getDerived().getSema().StartOpenMPDSABlock(
8905 OMPD_teams_distribute_parallel_for_simd, DirName, nullptr,
8906 D->getBeginLoc());
8907 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8908 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8909 return Res;
8910}
8911
8912template <typename Derived>
8913StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForDirective(
8914 OMPTeamsDistributeParallelForDirective *D) {
8915 DeclarationNameInfo DirName;
8916 getDerived().getSema().StartOpenMPDSABlock(
8917 OMPD_teams_distribute_parallel_for, DirName, nullptr, D->getBeginLoc());
8918 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
8919 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8920 return Res;
8921}
8922
8923template <typename Derived>
8924StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDirective(
8925 OMPTargetTeamsDirective *D) {
8926 DeclarationNameInfo DirName;
8927 getDerived().getSema().StartOpenMPDSABlock(OMPD_target_teams, DirName,
8928 nullptr, D->getBeginLoc());
8929 auto Res = getDerived().TransformOMPExecutableDirective(D);
8930 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8931 return Res;
8932}
8933
8934template <typename Derived>
8935StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDistributeDirective(
8936 OMPTargetTeamsDistributeDirective *D) {
8937 DeclarationNameInfo DirName;
8938 getDerived().getSema().StartOpenMPDSABlock(
8939 OMPD_target_teams_distribute, DirName, nullptr, D->getBeginLoc());
8940 auto Res = getDerived().TransformOMPExecutableDirective(D);
8941 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8942 return Res;
8943}
8944
8945template <typename Derived>
8946StmtResult
8947TreeTransform<Derived>::TransformOMPTargetTeamsDistributeParallelForDirective(
8948 OMPTargetTeamsDistributeParallelForDirective *D) {
8949 DeclarationNameInfo DirName;
8950 getDerived().getSema().StartOpenMPDSABlock(
8951 OMPD_target_teams_distribute_parallel_for, DirName, nullptr,
8952 D->getBeginLoc());
8953 auto Res = getDerived().TransformOMPExecutableDirective(D);
8954 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8955 return Res;
8956}
8957
8958template <typename Derived>
8959StmtResult TreeTransform<Derived>::
8960 TransformOMPTargetTeamsDistributeParallelForSimdDirective(
8961 OMPTargetTeamsDistributeParallelForSimdDirective *D) {
8962 DeclarationNameInfo DirName;
8963 getDerived().getSema().StartOpenMPDSABlock(
8964 OMPD_target_teams_distribute_parallel_for_simd, DirName, nullptr,
8965 D->getBeginLoc());
8966 auto Res = getDerived().TransformOMPExecutableDirective(D);
8967 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8968 return Res;
8969}
8970
8971template <typename Derived>
8972StmtResult
8973TreeTransform<Derived>::TransformOMPTargetTeamsDistributeSimdDirective(
8974 OMPTargetTeamsDistributeSimdDirective *D) {
8975 DeclarationNameInfo DirName;
8976 getDerived().getSema().StartOpenMPDSABlock(
8977 OMPD_target_teams_distribute_simd, DirName, nullptr, D->getBeginLoc());
8978 auto Res = getDerived().TransformOMPExecutableDirective(D);
8979 getDerived().getSema().EndOpenMPDSABlock(Res.get());
8980 return Res;
8981}
8982
8983
8984//===----------------------------------------------------------------------===//
8985// OpenMP clause transformation
8986//===----------------------------------------------------------------------===//
8987template <typename Derived>
8988OMPClause *TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *C) {
8989 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
8990 if (Cond.isInvalid())
8991 return nullptr;
8992 return getDerived().RebuildOMPIfClause(
8993 C->getNameModifier(), Cond.get(), C->getBeginLoc(), C->getLParenLoc(),
8994 C->getNameModifierLoc(), C->getColonLoc(), C->getEndLoc());
8995}
8996
8997template <typename Derived>
8998OMPClause *TreeTransform<Derived>::TransformOMPFinalClause(OMPFinalClause *C) {
8999 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
9000 if (Cond.isInvalid())
9001 return nullptr;
9002 return getDerived().RebuildOMPFinalClause(Cond.get(), C->getBeginLoc(),
9003 C->getLParenLoc(), C->getEndLoc());
9004}
9005
9006template <typename Derived>
9007OMPClause *
9008TreeTransform<Derived>::TransformOMPNumThreadsClause(OMPNumThreadsClause *C) {
9009 ExprResult NumThreads = getDerived().TransformExpr(C->getNumThreads());
9010 if (NumThreads.isInvalid())
9011 return nullptr;
9012 return getDerived().RebuildOMPNumThreadsClause(
9013 NumThreads.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9014}
9015
9016template <typename Derived>
9017OMPClause *
9018TreeTransform<Derived>::TransformOMPSafelenClause(OMPSafelenClause *C) {
9019 ExprResult E = getDerived().TransformExpr(C->getSafelen());
9020 if (E.isInvalid())
9021 return nullptr;
9022 return getDerived().RebuildOMPSafelenClause(
9023 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9024}
9025
9026template <typename Derived>
9027OMPClause *
9028TreeTransform<Derived>::TransformOMPAllocatorClause(OMPAllocatorClause *C) {
9029 ExprResult E = getDerived().TransformExpr(C->getAllocator());
9030 if (E.isInvalid())
9031 return nullptr;
9032 return getDerived().RebuildOMPAllocatorClause(
9033 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9034}
9035
9036template <typename Derived>
9037OMPClause *
9038TreeTransform<Derived>::TransformOMPSimdlenClause(OMPSimdlenClause *C) {
9039 ExprResult E = getDerived().TransformExpr(C->getSimdlen());
9040 if (E.isInvalid())
9041 return nullptr;
9042 return getDerived().RebuildOMPSimdlenClause(
9043 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9044}
9045
9046template <typename Derived>
9047OMPClause *
9048TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *C) {
9049 ExprResult E = getDerived().TransformExpr(C->getNumForLoops());
9050 if (E.isInvalid())
9051 return nullptr;
9052 return getDerived().RebuildOMPCollapseClause(
9053 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9054}
9055
9056template <typename Derived>
9057OMPClause *
9058TreeTransform<Derived>::TransformOMPDefaultClause(OMPDefaultClause *C) {
9059 return getDerived().RebuildOMPDefaultClause(
9060 C->getDefaultKind(), C->getDefaultKindKwLoc(), C->getBeginLoc(),
9061 C->getLParenLoc(), C->getEndLoc());
9062}
9063
9064template <typename Derived>
9065OMPClause *
9066TreeTransform<Derived>::TransformOMPProcBindClause(OMPProcBindClause *C) {
9067 return getDerived().RebuildOMPProcBindClause(
9068 C->getProcBindKind(), C->getProcBindKindKwLoc(), C->getBeginLoc(),
9069 C->getLParenLoc(), C->getEndLoc());
9070}
9071
9072template <typename Derived>
9073OMPClause *
9074TreeTransform<Derived>::TransformOMPScheduleClause(OMPScheduleClause *C) {
9075 ExprResult E = getDerived().TransformExpr(C->getChunkSize());
9076 if (E.isInvalid())
9077 return nullptr;
9078 return getDerived().RebuildOMPScheduleClause(
9079 C->getFirstScheduleModifier(), C->getSecondScheduleModifier(),
9080 C->getScheduleKind(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
9081 C->getFirstScheduleModifierLoc(), C->getSecondScheduleModifierLoc(),
9082 C->getScheduleKindLoc(), C->getCommaLoc(), C->getEndLoc());
9083}
9084
9085template <typename Derived>
9086OMPClause *
9087TreeTransform<Derived>::TransformOMPOrderedClause(OMPOrderedClause *C) {
9088 ExprResult E;
9089 if (auto *Num = C->getNumForLoops()) {
9090 E = getDerived().TransformExpr(Num);
9091 if (E.isInvalid())
9092 return nullptr;
9093 }
9094 return getDerived().RebuildOMPOrderedClause(C->getBeginLoc(), C->getEndLoc(),
9095 C->getLParenLoc(), E.get());
9096}
9097
9098template <typename Derived>
9099OMPClause *
9100TreeTransform<Derived>::TransformOMPDetachClause(OMPDetachClause *C) {
9101 ExprResult E;
9102 if (Expr *Evt = C->getEventHandler()) {
9103 E = getDerived().TransformExpr(Evt);
9104 if (E.isInvalid())
9105 return nullptr;
9106 }
9107 return getDerived().RebuildOMPDetachClause(E.get(), C->getBeginLoc(),
9108 C->getLParenLoc(), C->getEndLoc());
9109}
9110
9111template <typename Derived>
9112OMPClause *
9113TreeTransform<Derived>::TransformOMPNowaitClause(OMPNowaitClause *C) {
9114 // No need to rebuild this clause, no template-dependent parameters.
9115 return C;
9116}
9117
9118template <typename Derived>
9119OMPClause *
9120TreeTransform<Derived>::TransformOMPUntiedClause(OMPUntiedClause *C) {
9121 // No need to rebuild this clause, no template-dependent parameters.
9122 return C;
9123}
9124
9125template <typename Derived>
9126OMPClause *
9127TreeTransform<Derived>::TransformOMPMergeableClause(OMPMergeableClause *C) {
9128 // No need to rebuild this clause, no template-dependent parameters.
9129 return C;
9130}
9131
9132template <typename Derived>
9133OMPClause *TreeTransform<Derived>::TransformOMPReadClause(OMPReadClause *C) {
9134 // No need to rebuild this clause, no template-dependent parameters.
9135 return C;
9136}
9137
9138template <typename Derived>
9139OMPClause *TreeTransform<Derived>::TransformOMPWriteClause(OMPWriteClause *C) {
9140 // No need to rebuild this clause, no template-dependent parameters.
9141 return C;
9142}
9143
9144template <typename Derived>
9145OMPClause *
9146TreeTransform<Derived>::TransformOMPUpdateClause(OMPUpdateClause *C) {
9147 // No need to rebuild this clause, no template-dependent parameters.
9148 return C;
9149}
9150
9151template <typename Derived>
9152OMPClause *
9153TreeTransform<Derived>::TransformOMPCaptureClause(OMPCaptureClause *C) {
9154 // No need to rebuild this clause, no template-dependent parameters.
9155 return C;
9156}
9157
9158template <typename Derived>
9159OMPClause *
9160TreeTransform<Derived>::TransformOMPSeqCstClause(OMPSeqCstClause *C) {
9161 // No need to rebuild this clause, no template-dependent parameters.
9162 return C;
9163}
9164
9165template <typename Derived>
9166OMPClause *
9167TreeTransform<Derived>::TransformOMPAcqRelClause(OMPAcqRelClause *C) {
9168 // No need to rebuild this clause, no template-dependent parameters.
9169 return C;
9170}
9171
9172template <typename Derived>
9173OMPClause *
9174TreeTransform<Derived>::TransformOMPAcquireClause(OMPAcquireClause *C) {
9175 // No need to rebuild this clause, no template-dependent parameters.
9176 return C;
9177}
9178
9179template <typename Derived>
9180OMPClause *
9181TreeTransform<Derived>::TransformOMPReleaseClause(OMPReleaseClause *C) {
9182 // No need to rebuild this clause, no template-dependent parameters.
9183 return C;
9184}
9185
9186template <typename Derived>
9187OMPClause *
9188TreeTransform<Derived>::TransformOMPRelaxedClause(OMPRelaxedClause *C) {
9189 // No need to rebuild this clause, no template-dependent parameters.
9190 return C;
9191}
9192
9193template <typename Derived>
9194OMPClause *
9195TreeTransform<Derived>::TransformOMPThreadsClause(OMPThreadsClause *C) {
9196 // No need to rebuild this clause, no template-dependent parameters.
9197 return C;
9198}
9199
9200template <typename Derived>
9201OMPClause *TreeTransform<Derived>::TransformOMPSIMDClause(OMPSIMDClause *C) {
9202 // No need to rebuild this clause, no template-dependent parameters.
9203 return C;
9204}
9205
9206template <typename Derived>
9207OMPClause *
9208TreeTransform<Derived>::TransformOMPNogroupClause(OMPNogroupClause *C) {
9209 // No need to rebuild this clause, no template-dependent parameters.
9210 return C;
9211}
9212
9213template <typename Derived>
9214OMPClause *
9215TreeTransform<Derived>::TransformOMPDestroyClause(OMPDestroyClause *C) {
9216 // No need to rebuild this clause, no template-dependent parameters.
9217 return C;
9218}
9219
9220template <typename Derived>
9221OMPClause *TreeTransform<Derived>::TransformOMPUnifiedAddressClause(
9222 OMPUnifiedAddressClause *C) {
9223 llvm_unreachable("unified_address clause cannot appear in dependent context");
9224}
9225
9226template <typename Derived>
9227OMPClause *TreeTransform<Derived>::TransformOMPUnifiedSharedMemoryClause(
9228 OMPUnifiedSharedMemoryClause *C) {
9229 llvm_unreachable(
9230 "unified_shared_memory clause cannot appear in dependent context");
9231}
9232
9233template <typename Derived>
9234OMPClause *TreeTransform<Derived>::TransformOMPReverseOffloadClause(
9235 OMPReverseOffloadClause *C) {
9236 llvm_unreachable("reverse_offload clause cannot appear in dependent context");
9237}
9238
9239template <typename Derived>
9240OMPClause *TreeTransform<Derived>::TransformOMPDynamicAllocatorsClause(
9241 OMPDynamicAllocatorsClause *C) {
9242 llvm_unreachable(
9243 "dynamic_allocators clause cannot appear in dependent context");
9244}
9245
9246template <typename Derived>
9247OMPClause *TreeTransform<Derived>::TransformOMPAtomicDefaultMemOrderClause(
9248 OMPAtomicDefaultMemOrderClause *C) {
9249 llvm_unreachable(
9250 "atomic_default_mem_order clause cannot appear in dependent context");
9251}
9252
9253template <typename Derived>
9254OMPClause *
9255TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *C) {
9256 llvm::SmallVector<Expr *, 16> Vars;
9257 Vars.reserve(C->varlist_size());
9258 for (auto *VE : C->varlists()) {
9259 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9260 if (EVar.isInvalid())
9261 return nullptr;
9262 Vars.push_back(EVar.get());
9263 }
9264 return getDerived().RebuildOMPPrivateClause(
9265 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9266}
9267
9268template <typename Derived>
9269OMPClause *TreeTransform<Derived>::TransformOMPFirstprivateClause(
9270 OMPFirstprivateClause *C) {
9271 llvm::SmallVector<Expr *, 16> Vars;
9272 Vars.reserve(C->varlist_size());
9273 for (auto *VE : C->varlists()) {
9274 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9275 if (EVar.isInvalid())
9276 return nullptr;
9277 Vars.push_back(EVar.get());
9278 }
9279 return getDerived().RebuildOMPFirstprivateClause(
9280 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9281}
9282
9283template <typename Derived>
9284OMPClause *
9285TreeTransform<Derived>::TransformOMPLastprivateClause(OMPLastprivateClause *C) {
9286 llvm::SmallVector<Expr *, 16> Vars;
9287 Vars.reserve(C->varlist_size());
9288 for (auto *VE : C->varlists()) {
9289 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9290 if (EVar.isInvalid())
9291 return nullptr;
9292 Vars.push_back(EVar.get());
9293 }
9294 return getDerived().RebuildOMPLastprivateClause(
9295 Vars, C->getKind(), C->getKindLoc(), C->getColonLoc(), C->getBeginLoc(),
9296 C->getLParenLoc(), C->getEndLoc());
9297}
9298
9299template <typename Derived>
9300OMPClause *
9301TreeTransform<Derived>::TransformOMPSharedClause(OMPSharedClause *C) {
9302 llvm::SmallVector<Expr *, 16> Vars;
9303 Vars.reserve(C->varlist_size());
9304 for (auto *VE : C->varlists()) {
9305 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9306 if (EVar.isInvalid())
9307 return nullptr;
9308 Vars.push_back(EVar.get());
9309 }
9310 return getDerived().RebuildOMPSharedClause(Vars, C->getBeginLoc(),
9311 C->getLParenLoc(), C->getEndLoc());
9312}
9313
9314template <typename Derived>
9315OMPClause *
9316TreeTransform<Derived>::TransformOMPReductionClause(OMPReductionClause *C) {
9317 llvm::SmallVector<Expr *, 16> Vars;
9318 Vars.reserve(C->varlist_size());
9319 for (auto *VE : C->varlists()) {
9320 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9321 if (EVar.isInvalid())
9322 return nullptr;
9323 Vars.push_back(EVar.get());
9324 }
9325 CXXScopeSpec ReductionIdScopeSpec;
9326 ReductionIdScopeSpec.Adopt(C->getQualifierLoc());
9327
9328 DeclarationNameInfo NameInfo = C->getNameInfo();
9329 if (NameInfo.getName()) {
9330 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
9331 if (!NameInfo.getName())
9332 return nullptr;
9333 }
9334 // Build a list of all UDR decls with the same names ranged by the Scopes.
9335 // The Scope boundary is a duplication of the previous decl.
9336 llvm::SmallVector<Expr *, 16> UnresolvedReductions;
9337 for (auto *E : C->reduction_ops()) {
9338 // Transform all the decls.
9339 if (E) {
9340 auto *ULE = cast<UnresolvedLookupExpr>(E);
9341 UnresolvedSet<8> Decls;
9342 for (auto *D : ULE->decls()) {
9343 NamedDecl *InstD =
9344 cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
9345 Decls.addDecl(InstD, InstD->getAccess());
9346 }
9347 UnresolvedReductions.push_back(
9348 UnresolvedLookupExpr::Create(
9349 SemaRef.Context, /*NamingClass=*/nullptr,
9350 ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context),
9351 NameInfo, /*ADL=*/true, ULE->isOverloaded(),
9352 Decls.begin(), Decls.end()));
9353 } else
9354 UnresolvedReductions.push_back(nullptr);
9355 }
9356 return getDerived().RebuildOMPReductionClause(
9357 Vars, C->getModifier(), C->getBeginLoc(), C->getLParenLoc(),
9358 C->getModifierLoc(), C->getColonLoc(), C->getEndLoc(),
9359 ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
9360}
9361
9362template <typename Derived>
9363OMPClause *TreeTransform<Derived>::TransformOMPTaskReductionClause(
9364 OMPTaskReductionClause *C) {
9365 llvm::SmallVector<Expr *, 16> Vars;
9366 Vars.reserve(C->varlist_size());
9367 for (auto *VE : C->varlists()) {
9368 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9369 if (EVar.isInvalid())
9370 return nullptr;
9371 Vars.push_back(EVar.get());
9372 }
9373 CXXScopeSpec ReductionIdScopeSpec;
9374 ReductionIdScopeSpec.Adopt(C->getQualifierLoc());
9375
9376 DeclarationNameInfo NameInfo = C->getNameInfo();
9377 if (NameInfo.getName()) {
9378 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
9379 if (!NameInfo.getName())
9380 return nullptr;
9381 }
9382 // Build a list of all UDR decls with the same names ranged by the Scopes.
9383 // The Scope boundary is a duplication of the previous decl.
9384 llvm::SmallVector<Expr *, 16> UnresolvedReductions;
9385 for (auto *E : C->reduction_ops()) {
9386 // Transform all the decls.
9387 if (E) {
9388 auto *ULE = cast<UnresolvedLookupExpr>(E);
9389 UnresolvedSet<8> Decls;
9390 for (auto *D : ULE->decls()) {
9391 NamedDecl *InstD =
9392 cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
9393 Decls.addDecl(InstD, InstD->getAccess());
9394 }
9395 UnresolvedReductions.push_back(UnresolvedLookupExpr::Create(
9396 SemaRef.Context, /*NamingClass=*/nullptr,
9397 ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context), NameInfo,
9398 /*ADL=*/true, ULE->isOverloaded(), Decls.begin(), Decls.end()));
9399 } else
9400 UnresolvedReductions.push_back(nullptr);
9401 }
9402 return getDerived().RebuildOMPTaskReductionClause(
9403 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
9404 C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
9405}
9406
9407template <typename Derived>
9408OMPClause *
9409TreeTransform<Derived>::TransformOMPInReductionClause(OMPInReductionClause *C) {
9410 llvm::SmallVector<Expr *, 16> Vars;
9411 Vars.reserve(C->varlist_size());
9412 for (auto *VE : C->varlists()) {
9413 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9414 if (EVar.isInvalid())
9415 return nullptr;
9416 Vars.push_back(EVar.get());
9417 }
9418 CXXScopeSpec ReductionIdScopeSpec;
9419 ReductionIdScopeSpec.Adopt(C->getQualifierLoc());
9420
9421 DeclarationNameInfo NameInfo = C->getNameInfo();
9422 if (NameInfo.getName()) {
9423 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
9424 if (!NameInfo.getName())
9425 return nullptr;
9426 }
9427 // Build a list of all UDR decls with the same names ranged by the Scopes.
9428 // The Scope boundary is a duplication of the previous decl.
9429 llvm::SmallVector<Expr *, 16> UnresolvedReductions;
9430 for (auto *E : C->reduction_ops()) {
9431 // Transform all the decls.
9432 if (E) {
9433 auto *ULE = cast<UnresolvedLookupExpr>(E);
9434 UnresolvedSet<8> Decls;
9435 for (auto *D : ULE->decls()) {
9436 NamedDecl *InstD =
9437 cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
9438 Decls.addDecl(InstD, InstD->getAccess());
9439 }
9440 UnresolvedReductions.push_back(UnresolvedLookupExpr::Create(
9441 SemaRef.Context, /*NamingClass=*/nullptr,
9442 ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context), NameInfo,
9443 /*ADL=*/true, ULE->isOverloaded(), Decls.begin(), Decls.end()));
9444 } else
9445 UnresolvedReductions.push_back(nullptr);
9446 }
9447 return getDerived().RebuildOMPInReductionClause(
9448 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
9449 C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
9450}
9451
9452template <typename Derived>
9453OMPClause *
9454TreeTransform<Derived>::TransformOMPLinearClause(OMPLinearClause *C) {
9455 llvm::SmallVector<Expr *, 16> Vars;
9456 Vars.reserve(C->varlist_size());
9457 for (auto *VE : C->varlists()) {
9458 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9459 if (EVar.isInvalid())
9460 return nullptr;
9461 Vars.push_back(EVar.get());
9462 }
9463 ExprResult Step = getDerived().TransformExpr(C->getStep());
9464 if (Step.isInvalid())
9465 return nullptr;
9466 return getDerived().RebuildOMPLinearClause(
9467 Vars, Step.get(), C->getBeginLoc(), C->getLParenLoc(), C->getModifier(),
9468 C->getModifierLoc(), C->getColonLoc(), C->getEndLoc());
9469}
9470
9471template <typename Derived>
9472OMPClause *
9473TreeTransform<Derived>::TransformOMPAlignedClause(OMPAlignedClause *C) {
9474 llvm::SmallVector<Expr *, 16> Vars;
9475 Vars.reserve(C->varlist_size());
9476 for (auto *VE : C->varlists()) {
9477 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9478 if (EVar.isInvalid())
9479 return nullptr;
9480 Vars.push_back(EVar.get());
9481 }
9482 ExprResult Alignment = getDerived().TransformExpr(C->getAlignment());
9483 if (Alignment.isInvalid())
9484 return nullptr;
9485 return getDerived().RebuildOMPAlignedClause(
9486 Vars, Alignment.get(), C->getBeginLoc(), C->getLParenLoc(),
9487 C->getColonLoc(), C->getEndLoc());
9488}
9489
9490template <typename Derived>
9491OMPClause *
9492TreeTransform<Derived>::TransformOMPCopyinClause(OMPCopyinClause *C) {
9493 llvm::SmallVector<Expr *, 16> Vars;
9494 Vars.reserve(C->varlist_size());
9495 for (auto *VE : C->varlists()) {
9496 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9497 if (EVar.isInvalid())
9498 return nullptr;
9499 Vars.push_back(EVar.get());
9500 }
9501 return getDerived().RebuildOMPCopyinClause(Vars, C->getBeginLoc(),
9502 C->getLParenLoc(), C->getEndLoc());
9503}
9504
9505template <typename Derived>
9506OMPClause *
9507TreeTransform<Derived>::TransformOMPCopyprivateClause(OMPCopyprivateClause *C) {
9508 llvm::SmallVector<Expr *, 16> Vars;
9509 Vars.reserve(C->varlist_size());
9510 for (auto *VE : C->varlists()) {
9511 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9512 if (EVar.isInvalid())
9513 return nullptr;
9514 Vars.push_back(EVar.get());
9515 }
9516 return getDerived().RebuildOMPCopyprivateClause(
9517 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9518}
9519
9520template <typename Derived>
9521OMPClause *TreeTransform<Derived>::TransformOMPFlushClause(OMPFlushClause *C) {
9522 llvm::SmallVector<Expr *, 16> Vars;
9523 Vars.reserve(C->varlist_size());
9524 for (auto *VE : C->varlists()) {
9525 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9526 if (EVar.isInvalid())
9527 return nullptr;
9528 Vars.push_back(EVar.get());
9529 }
9530 return getDerived().RebuildOMPFlushClause(Vars, C->getBeginLoc(),
9531 C->getLParenLoc(), C->getEndLoc());
9532}
9533
9534template <typename Derived>
9535OMPClause *
9536TreeTransform<Derived>::TransformOMPDepobjClause(OMPDepobjClause *C) {
9537 ExprResult E = getDerived().TransformExpr(C->getDepobj());
9538 if (E.isInvalid())
9539 return nullptr;
9540 return getDerived().RebuildOMPDepobjClause(E.get(), C->getBeginLoc(),
9541 C->getLParenLoc(), C->getEndLoc());
9542}
9543
9544template <typename Derived>
9545OMPClause *
9546TreeTransform<Derived>::TransformOMPDependClause(OMPDependClause *C) {
9547 llvm::SmallVector<Expr *, 16> Vars;
9548 Expr *DepModifier = C->getModifier();
9549 if (DepModifier) {
9550 ExprResult DepModRes = getDerived().TransformExpr(DepModifier);
9551 if (DepModRes.isInvalid())
9552 return nullptr;
9553 DepModifier = DepModRes.get();
9554 }
9555 Vars.reserve(C->varlist_size());
9556 for (auto *VE : C->varlists()) {
9557 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9558 if (EVar.isInvalid())
9559 return nullptr;
9560 Vars.push_back(EVar.get());
9561 }
9562 return getDerived().RebuildOMPDependClause(
9563 DepModifier, C->getDependencyKind(), C->getDependencyLoc(),
9564 C->getColonLoc(), Vars, C->getBeginLoc(), C->getLParenLoc(),
9565 C->getEndLoc());
9566}
9567
9568template <typename Derived>
9569OMPClause *
9570TreeTransform<Derived>::TransformOMPDeviceClause(OMPDeviceClause *C) {
9571 ExprResult E = getDerived().TransformExpr(C->getDevice());
9572 if (E.isInvalid())
9573 return nullptr;
9574 return getDerived().RebuildOMPDeviceClause(
9575 C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
9576 C->getModifierLoc(), C->getEndLoc());
9577}
9578
9579template <typename Derived, class T>
9580bool transformOMPMappableExprListClause(
9581 TreeTransform<Derived> &TT, OMPMappableExprListClause<T> *C,
9582 llvm::SmallVectorImpl<Expr *> &Vars, CXXScopeSpec &MapperIdScopeSpec,
9583 DeclarationNameInfo &MapperIdInfo,
9584 llvm::SmallVectorImpl<Expr *> &UnresolvedMappers) {
9585 // Transform expressions in the list.
9586 Vars.reserve(C->varlist_size());
9587 for (auto *VE : C->varlists()) {
9588 ExprResult EVar = TT.getDerived().TransformExpr(cast<Expr>(VE));
9589 if (EVar.isInvalid())
9590 return true;
9591 Vars.push_back(EVar.get());
9592 }
9593 // Transform mapper scope specifier and identifier.
9594 NestedNameSpecifierLoc QualifierLoc;
9595 if (C->getMapperQualifierLoc()) {
9596 QualifierLoc = TT.getDerived().TransformNestedNameSpecifierLoc(
9597 C->getMapperQualifierLoc());
9598 if (!QualifierLoc)
9599 return true;
9600 }
9601 MapperIdScopeSpec.Adopt(QualifierLoc);
9602 MapperIdInfo = C->getMapperIdInfo();
9603 if (MapperIdInfo.getName()) {
9604 MapperIdInfo = TT.getDerived().TransformDeclarationNameInfo(MapperIdInfo);
9605 if (!MapperIdInfo.getName())
9606 return true;
9607 }
9608 // Build a list of all candidate OMPDeclareMapperDecls, which is provided by
9609 // the previous user-defined mapper lookup in dependent environment.
9610 for (auto *E : C->mapperlists()) {
9611 // Transform all the decls.
9612 if (E) {
9613 auto *ULE = cast<UnresolvedLookupExpr>(E);
9614 UnresolvedSet<8> Decls;
9615 for (auto *D : ULE->decls()) {
9616 NamedDecl *InstD =
9617 cast<NamedDecl>(TT.getDerived().TransformDecl(E->getExprLoc(), D));
9618 Decls.addDecl(InstD, InstD->getAccess());
9619 }
9620 UnresolvedMappers.push_back(UnresolvedLookupExpr::Create(
9621 TT.getSema().Context, /*NamingClass=*/nullptr,
9622 MapperIdScopeSpec.getWithLocInContext(TT.getSema().Context),
9623 MapperIdInfo, /*ADL=*/true, ULE->isOverloaded(), Decls.begin(),
9624 Decls.end()));
9625 } else {
9626 UnresolvedMappers.push_back(nullptr);
9627 }
9628 }
9629 return false;
9630}
9631
9632template <typename Derived>
9633OMPClause *TreeTransform<Derived>::TransformOMPMapClause(OMPMapClause *C) {
9634 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9635 llvm::SmallVector<Expr *, 16> Vars;
9636 CXXScopeSpec MapperIdScopeSpec;
9637 DeclarationNameInfo MapperIdInfo;
9638 llvm::SmallVector<Expr *, 16> UnresolvedMappers;
9639 if (transformOMPMappableExprListClause<Derived, OMPMapClause>(
9640 *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
9641 return nullptr;
9642 return getDerived().RebuildOMPMapClause(
9643 C->getMapTypeModifiers(), C->getMapTypeModifiersLoc(), MapperIdScopeSpec,
9644 MapperIdInfo, C->getMapType(), C->isImplicitMapType(), C->getMapLoc(),
9645 C->getColonLoc(), Vars, Locs, UnresolvedMappers);
9646}
9647
9648template <typename Derived>
9649OMPClause *
9650TreeTransform<Derived>::TransformOMPAllocateClause(OMPAllocateClause *C) {
9651 Expr *Allocator = C->getAllocator();
9652 if (Allocator) {
9653 ExprResult AllocatorRes = getDerived().TransformExpr(Allocator);
9654 if (AllocatorRes.isInvalid())
9655 return nullptr;
9656 Allocator = AllocatorRes.get();
9657 }
9658 llvm::SmallVector<Expr *, 16> Vars;
9659 Vars.reserve(C->varlist_size());
9660 for (auto *VE : C->varlists()) {
9661 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9662 if (EVar.isInvalid())
9663 return nullptr;
9664 Vars.push_back(EVar.get());
9665 }
9666 return getDerived().RebuildOMPAllocateClause(
9667 Allocator, Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
9668 C->getEndLoc());
9669}
9670
9671template <typename Derived>
9672OMPClause *
9673TreeTransform<Derived>::TransformOMPNumTeamsClause(OMPNumTeamsClause *C) {
9674 ExprResult E = getDerived().TransformExpr(C->getNumTeams());
9675 if (E.isInvalid())
9676 return nullptr;
9677 return getDerived().RebuildOMPNumTeamsClause(
9678 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9679}
9680
9681template <typename Derived>
9682OMPClause *
9683TreeTransform<Derived>::TransformOMPThreadLimitClause(OMPThreadLimitClause *C) {
9684 ExprResult E = getDerived().TransformExpr(C->getThreadLimit());
9685 if (E.isInvalid())
9686 return nullptr;
9687 return getDerived().RebuildOMPThreadLimitClause(
9688 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9689}
9690
9691template <typename Derived>
9692OMPClause *
9693TreeTransform<Derived>::TransformOMPPriorityClause(OMPPriorityClause *C) {
9694 ExprResult E = getDerived().TransformExpr(C->getPriority());
9695 if (E.isInvalid())
9696 return nullptr;
9697 return getDerived().RebuildOMPPriorityClause(
9698 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9699}
9700
9701template <typename Derived>
9702OMPClause *
9703TreeTransform<Derived>::TransformOMPGrainsizeClause(OMPGrainsizeClause *C) {
9704 ExprResult E = getDerived().TransformExpr(C->getGrainsize());
9705 if (E.isInvalid())
9706 return nullptr;
9707 return getDerived().RebuildOMPGrainsizeClause(
9708 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9709}
9710
9711template <typename Derived>
9712OMPClause *
9713TreeTransform<Derived>::TransformOMPNumTasksClause(OMPNumTasksClause *C) {
9714 ExprResult E = getDerived().TransformExpr(C->getNumTasks());
9715 if (E.isInvalid())
9716 return nullptr;
9717 return getDerived().RebuildOMPNumTasksClause(
9718 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9719}
9720
9721template <typename Derived>
9722OMPClause *TreeTransform<Derived>::TransformOMPHintClause(OMPHintClause *C) {
9723 ExprResult E = getDerived().TransformExpr(C->getHint());
9724 if (E.isInvalid())
9725 return nullptr;
9726 return getDerived().RebuildOMPHintClause(E.get(), C->getBeginLoc(),
9727 C->getLParenLoc(), C->getEndLoc());
9728}
9729
9730template <typename Derived>
9731OMPClause *TreeTransform<Derived>::TransformOMPDistScheduleClause(
9732 OMPDistScheduleClause *C) {
9733 ExprResult E = getDerived().TransformExpr(C->getChunkSize());
9734 if (E.isInvalid())
9735 return nullptr;
9736 return getDerived().RebuildOMPDistScheduleClause(
9737 C->getDistScheduleKind(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
9738 C->getDistScheduleKindLoc(), C->getCommaLoc(), C->getEndLoc());
9739}
9740
9741template <typename Derived>
9742OMPClause *
9743TreeTransform<Derived>::TransformOMPDefaultmapClause(OMPDefaultmapClause *C) {
9744 // Rebuild Defaultmap Clause since we need to invoke the checking of
9745 // defaultmap(none:variable-category) after template initialization.
9746 return getDerived().RebuildOMPDefaultmapClause(C->getDefaultmapModifier(),
9747 C->getDefaultmapKind(),
9748 C->getBeginLoc(),
9749 C->getLParenLoc(),
9750 C->getDefaultmapModifierLoc(),
9751 C->getDefaultmapKindLoc(),
9752 C->getEndLoc());
9753}
9754
9755template <typename Derived>
9756OMPClause *TreeTransform<Derived>::TransformOMPToClause(OMPToClause *C) {
9757 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9758 llvm::SmallVector<Expr *, 16> Vars;
9759 CXXScopeSpec MapperIdScopeSpec;
9760 DeclarationNameInfo MapperIdInfo;
9761 llvm::SmallVector<Expr *, 16> UnresolvedMappers;
9762 if (transformOMPMappableExprListClause<Derived, OMPToClause>(
9763 *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
9764 return nullptr;
9765 return getDerived().RebuildOMPToClause(
9766 C->getMotionModifiers(), C->getMotionModifiersLoc(), MapperIdScopeSpec,
9767 MapperIdInfo, C->getColonLoc(), Vars, Locs, UnresolvedMappers);
9768}
9769
9770template <typename Derived>
9771OMPClause *TreeTransform<Derived>::TransformOMPFromClause(OMPFromClause *C) {
9772 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9773 llvm::SmallVector<Expr *, 16> Vars;
9774 CXXScopeSpec MapperIdScopeSpec;
9775 DeclarationNameInfo MapperIdInfo;
9776 llvm::SmallVector<Expr *, 16> UnresolvedMappers;
9777 if (transformOMPMappableExprListClause<Derived, OMPFromClause>(
9778 *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
9779 return nullptr;
9780 return getDerived().RebuildOMPFromClause(
9781 C->getMotionModifiers(), C->getMotionModifiersLoc(), MapperIdScopeSpec,
9782 MapperIdInfo, C->getColonLoc(), Vars, Locs, UnresolvedMappers);
9783}
9784
9785template <typename Derived>
9786OMPClause *TreeTransform<Derived>::TransformOMPUseDevicePtrClause(
9787 OMPUseDevicePtrClause *C) {
9788 llvm::SmallVector<Expr *, 16> Vars;
9789 Vars.reserve(C->varlist_size());
9790 for (auto *VE : C->varlists()) {
9791 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9792 if (EVar.isInvalid())
9793 return nullptr;
9794 Vars.push_back(EVar.get());
9795 }
9796 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9797 return getDerived().RebuildOMPUseDevicePtrClause(Vars, Locs);
9798}
9799
9800template <typename Derived>
9801OMPClause *TreeTransform<Derived>::TransformOMPUseDeviceAddrClause(
9802 OMPUseDeviceAddrClause *C) {
9803 llvm::SmallVector<Expr *, 16> Vars;
9804 Vars.reserve(C->varlist_size());
9805 for (auto *VE : C->varlists()) {
9806 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9807 if (EVar.isInvalid())
9808 return nullptr;
9809 Vars.push_back(EVar.get());
9810 }
9811 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9812 return getDerived().RebuildOMPUseDeviceAddrClause(Vars, Locs);
9813}
9814
9815template <typename Derived>
9816OMPClause *
9817TreeTransform<Derived>::TransformOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) {
9818 llvm::SmallVector<Expr *, 16> Vars;
9819 Vars.reserve(C->varlist_size());
9820 for (auto *VE : C->varlists()) {
9821 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9822 if (EVar.isInvalid())
9823 return nullptr;
9824 Vars.push_back(EVar.get());
9825 }
9826 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9827 return getDerived().RebuildOMPIsDevicePtrClause(Vars, Locs);
9828}
9829
9830template <typename Derived>
9831OMPClause *
9832TreeTransform<Derived>::TransformOMPNontemporalClause(OMPNontemporalClause *C) {
9833 llvm::SmallVector<Expr *, 16> Vars;
9834 Vars.reserve(C->varlist_size());
9835 for (auto *VE : C->varlists()) {
9836 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9837 if (EVar.isInvalid())
9838 return nullptr;
9839 Vars.push_back(EVar.get());
9840 }
9841 return getDerived().RebuildOMPNontemporalClause(
9842 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9843}
9844
9845template <typename Derived>
9846OMPClause *
9847TreeTransform<Derived>::TransformOMPInclusiveClause(OMPInclusiveClause *C) {
9848 llvm::SmallVector<Expr *, 16> Vars;
9849 Vars.reserve(C->varlist_size());
9850 for (auto *VE : C->varlists()) {
9851 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9852 if (EVar.isInvalid())
9853 return nullptr;
9854 Vars.push_back(EVar.get());
9855 }
9856 return getDerived().RebuildOMPInclusiveClause(
9857 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9858}
9859
9860template <typename Derived>
9861OMPClause *
9862TreeTransform<Derived>::TransformOMPExclusiveClause(OMPExclusiveClause *C) {
9863 llvm::SmallVector<Expr *, 16> Vars;
9864 Vars.reserve(C->varlist_size());
9865 for (auto *VE : C->varlists()) {
9866 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
9867 if (EVar.isInvalid())
9868 return nullptr;
9869 Vars.push_back(EVar.get());
9870 }
9871 return getDerived().RebuildOMPExclusiveClause(
9872 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9873}
9874
9875template <typename Derived>
9876OMPClause *TreeTransform<Derived>::TransformOMPUsesAllocatorsClause(
9877 OMPUsesAllocatorsClause *C) {
9878 SmallVector<Sema::UsesAllocatorsData, 16> Data;
9879 Data.reserve(C->getNumberOfAllocators());
9880 for (unsigned I = 0, E = C->getNumberOfAllocators(); I < E; ++I) {
9881 OMPUsesAllocatorsClause::Data D = C->getAllocatorData(I);
9882 ExprResult Allocator = getDerived().TransformExpr(D.Allocator);
9883 if (Allocator.isInvalid())
9884 continue;
9885 ExprResult AllocatorTraits;
9886 if (Expr *AT = D.AllocatorTraits) {
9887 AllocatorTraits = getDerived().TransformExpr(AT);
9888 if (AllocatorTraits.isInvalid())
9889 continue;
9890 }
9891 Sema::UsesAllocatorsData &NewD = Data.emplace_back();
9892 NewD.Allocator = Allocator.get();
9893 NewD.AllocatorTraits = AllocatorTraits.get();
9894 NewD.LParenLoc = D.LParenLoc;
9895 NewD.RParenLoc = D.RParenLoc;
9896 }
9897 return getDerived().RebuildOMPUsesAllocatorsClause(
9898 Data, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
9899}
9900
9901template <typename Derived>
9902OMPClause *
9903TreeTransform<Derived>::TransformOMPAffinityClause(OMPAffinityClause *C) {
9904 SmallVector<Expr *, 4> Locators;
9905 Locators.reserve(C->varlist_size());
9906 ExprResult ModifierRes;
9907 if (Expr *Modifier = C->getModifier()) {
9908 ModifierRes = getDerived().TransformExpr(Modifier);
9909 if (ModifierRes.isInvalid())
9910 return nullptr;
9911 }
9912 for (Expr *E : C->varlists()) {
9913 ExprResult Locator = getDerived().TransformExpr(E);
9914 if (Locator.isInvalid())
9915 continue;
9916 Locators.push_back(Locator.get());
9917 }
9918 return getDerived().RebuildOMPAffinityClause(
9919 C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(), C->getEndLoc(),
9920 ModifierRes.get(), Locators);
9921}
9922
9923template <typename Derived>
9924OMPClause *TreeTransform<Derived>::TransformOMPOrderClause(OMPOrderClause *C) {
9925 return getDerived().RebuildOMPOrderClause(C->getKind(), C->getKindKwLoc(),
9926 C->getBeginLoc(), C->getLParenLoc(),
9927 C->getEndLoc());
9928}
9929
9930//===----------------------------------------------------------------------===//
9931// Expression transformation
9932//===----------------------------------------------------------------------===//
9933template<typename Derived>
9934ExprResult
9935TreeTransform<Derived>::TransformConstantExpr(ConstantExpr *E) {
9936 return TransformExpr(E->getSubExpr());
9937}
9938
9939template<typename Derived>
9940ExprResult
9941TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) {
9942 if (!E->isTypeDependent())
9943 return E;
9944
9945 return getDerived().RebuildPredefinedExpr(E->getLocation(),
9946 E->getIdentKind());
9947}
9948
9949template<typename Derived>
9950ExprResult
9951TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) {
9952 NestedNameSpecifierLoc QualifierLoc;
9953 if (E->getQualifierLoc()) {
9954 QualifierLoc
9955 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
9956 if (!QualifierLoc)
9957 return ExprError();
9958 }
9959
9960 ValueDecl *ND
9961 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(),
9962 E->getDecl()));
9963 if (!ND)
9964 return ExprError();
9965
9966 NamedDecl *Found = ND;
9967 if (E->getFoundDecl() != E->getDecl()) {
9968 Found = cast_or_null<NamedDecl>(
9969 getDerived().TransformDecl(E->getLocation(), E->getFoundDecl()));
9970 if (!Found)
9971 return ExprError();
9972 }
9973
9974 DeclarationNameInfo NameInfo = E->getNameInfo();
9975 if (NameInfo.getName()) {
9976 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
9977 if (!NameInfo.getName())
9978 return ExprError();
9979 }
9980
9981 if (!getDerived().AlwaysRebuild() &&
9982 QualifierLoc == E->getQualifierLoc() &&
9983 ND == E->getDecl() &&
9984 Found == E->getFoundDecl() &&
9985 NameInfo.getName() == E->getDecl()->getDeclName() &&
9986 !E->hasExplicitTemplateArgs()) {
9987
9988 // Mark it referenced in the new context regardless.
9989 // FIXME: this is a bit instantiation-specific.
9990 SemaRef.MarkDeclRefReferenced(E);
9991
9992 return E;
9993 }
9994
9995 TemplateArgumentListInfo TransArgs, *TemplateArgs = nullptr;
9996 if (E->hasExplicitTemplateArgs()) {
9997 TemplateArgs = &TransArgs;
9998 TransArgs.setLAngleLoc(E->getLAngleLoc());
9999 TransArgs.setRAngleLoc(E->getRAngleLoc());
10000 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
10001 E->getNumTemplateArgs(),
10002 TransArgs))
10003 return ExprError();
10004 }
10005
10006 return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo,
10007 Found, TemplateArgs);
10008}
10009
10010template<typename Derived>
10011ExprResult
10012TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) {
10013 return E;
10014}
10015
10016template <typename Derived>
10017ExprResult TreeTransform<Derived>::TransformFixedPointLiteral(
10018 FixedPointLiteral *E) {
10019 return E;
10020}
10021
10022template<typename Derived>
10023ExprResult
10024TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) {
10025 return E;
10026}
10027
10028template<typename Derived>
10029ExprResult
10030TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) {
10031 return E;
10032}
10033
10034template<typename Derived>
10035ExprResult
10036TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) {
10037 return E;
10038}
10039
10040template<typename Derived>
10041ExprResult
10042TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) {
10043 return E;
10044}
10045
10046template<typename Derived>
10047ExprResult
10048TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *E) {
10049 if (FunctionDecl *FD = E->getDirectCallee())
10050 SemaRef.MarkFunctionReferenced(E->getBeginLoc(), FD);
10051 return SemaRef.MaybeBindToTemporary(E);
10052}
10053
10054template<typename Derived>
10055ExprResult
10056TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) {
10057 ExprResult ControllingExpr =
10058 getDerived().TransformExpr(E->getControllingExpr());
10059 if (ControllingExpr.isInvalid())
10060 return ExprError();
10061
10062 SmallVector<Expr *, 4> AssocExprs;
10063 SmallVector<TypeSourceInfo *, 4> AssocTypes;
10064 for (const GenericSelectionExpr::Association Assoc : E->associations()) {
10065 TypeSourceInfo *TSI = Assoc.getTypeSourceInfo();
10066 if (TSI) {
10067 TypeSourceInfo *AssocType = getDerived().TransformType(TSI);
10068 if (!AssocType)
10069 return ExprError();
10070 AssocTypes.push_back(AssocType);
10071 } else {
10072 AssocTypes.push_back(nullptr);
10073 }
10074
10075 ExprResult AssocExpr =
10076 getDerived().TransformExpr(Assoc.getAssociationExpr());
10077 if (AssocExpr.isInvalid())
10078 return ExprError();
10079 AssocExprs.push_back(AssocExpr.get());
10080 }
10081
10082 return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(),
10083 E->getDefaultLoc(),
10084 E->getRParenLoc(),
10085 ControllingExpr.get(),
10086 AssocTypes,
10087 AssocExprs);
10088}
10089
10090template<typename Derived>
10091ExprResult
10092TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) {
10093 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
10094 if (SubExpr.isInvalid())
10095 return ExprError();
10096
10097 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
10098 return E;
10099
10100 return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(),
10101 E->getRParen());
10102}
10103
10104/// The operand of a unary address-of operator has special rules: it's
10105/// allowed to refer to a non-static member of a class even if there's no 'this'
10106/// object available.
10107template<typename Derived>
10108ExprResult
10109TreeTransform<Derived>::TransformAddressOfOperand(Expr *E) {
10110 if (DependentScopeDeclRefExpr *DRE = dyn_cast<DependentScopeDeclRefExpr>(E))
10111 return getDerived().TransformDependentScopeDeclRefExpr(DRE, true, nullptr);
10112 else
10113 return getDerived().TransformExpr(E);
10114}
10115
10116template<typename Derived>
10117ExprResult
10118TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) {
10119 ExprResult SubExpr;
10120 if (E->getOpcode() == UO_AddrOf)
10121 SubExpr = TransformAddressOfOperand(E->getSubExpr());
10122 else
10123 SubExpr = TransformExpr(E->getSubExpr());
10124 if (SubExpr.isInvalid())
10125 return ExprError();
10126
10127 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
10128 return E;
10129
10130 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(),
10131 E->getOpcode(),
10132 SubExpr.get());
10133}
10134
10135template<typename Derived>
10136ExprResult
10137TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) {
10138 // Transform the type.
10139 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
10140 if (!Type)
10141 return ExprError();
10142
10143 // Transform all of the components into components similar to what the
10144 // parser uses.
10145 // FIXME: It would be slightly more efficient in the non-dependent case to
10146 // just map FieldDecls, rather than requiring the rebuilder to look for
10147 // the fields again. However, __builtin_offsetof is rare enough in
10148 // template code that we don't care.
10149 bool ExprChanged = false;
10150 typedef Sema::OffsetOfComponent Component;
10151 SmallVector<Component, 4> Components;
10152 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
10153 const OffsetOfNode &ON = E->getComponent(I);
10154 Component Comp;
10155 Comp.isBrackets = true;
10156 Comp.LocStart = ON.getSourceRange().getBegin();
10157 Comp.LocEnd = ON.getSourceRange().getEnd();
10158 switch (ON.getKind()) {
10159 case OffsetOfNode::Array: {
10160 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex());
10161 ExprResult Index = getDerived().TransformExpr(FromIndex);
10162 if (Index.isInvalid())
10163 return ExprError();
10164
10165 ExprChanged = ExprChanged || Index.get() != FromIndex;
10166 Comp.isBrackets = true;
10167 Comp.U.E = Index.get();
10168 break;
10169 }
10170
10171 case OffsetOfNode::Field:
10172 case OffsetOfNode::Identifier:
10173 Comp.isBrackets = false;
10174 Comp.U.IdentInfo = ON.getFieldName();
10175 if (!Comp.U.IdentInfo)
10176 continue;
10177
10178 break;
10179
10180 case OffsetOfNode::Base:
10181 // Will be recomputed during the rebuild.
10182 continue;
10183 }
10184
10185 Components.push_back(Comp);
10186 }
10187
10188 // If nothing changed, retain the existing expression.
10189 if (!getDerived().AlwaysRebuild() &&
10190 Type == E->getTypeSourceInfo() &&
10191 !ExprChanged)
10192 return E;
10193
10194 // Build a new offsetof expression.
10195 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type,
10196 Components, E->getRParenLoc());
10197}
10198
10199template<typename Derived>
10200ExprResult
10201TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) {
10202 assert((!E->getSourceExpr() || getDerived().AlreadyTransformed(E->getType())) &&
10203 "opaque value expression requires transformation");
10204 return E;
10205}
10206
10207template<typename Derived>
10208ExprResult
10209TreeTransform<Derived>::TransformTypoExpr(TypoExpr *E) {
10210 return E;
10211}
10212
10213template <typename Derived>
10214ExprResult TreeTransform<Derived>::TransformRecoveryExpr(RecoveryExpr *E) {
10215 llvm::SmallVector<Expr *, 8> Children;
10216 bool Changed = false;
10217 for (Expr *C : E->subExpressions()) {
10218 ExprResult NewC = getDerived().TransformExpr(C);
10219 if (NewC.isInvalid())
10220 return ExprError();
10221 Children.push_back(NewC.get());
10222
10223 Changed |= NewC.get() != C;
10224 }
10225 if (!getDerived().AlwaysRebuild() && !Changed)
10226 return E;
10227 return getDerived().RebuildRecoveryExpr(E->getBeginLoc(), E->getEndLoc(),
10228 Children, E->getType());
10229}
10230
10231template<typename Derived>
10232ExprResult
10233TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) {
10234 // Rebuild the syntactic form. The original syntactic form has
10235 // opaque-value expressions in it, so strip those away and rebuild
10236 // the result. This is a really awful way of doing this, but the
10237 // better solution (rebuilding the semantic expressions and
10238 // rebinding OVEs as necessary) doesn't work; we'd need
10239 // TreeTransform to not strip away implicit conversions.
10240 Expr *newSyntacticForm = SemaRef.recreateSyntacticForm(E);
10241 ExprResult result = getDerived().TransformExpr(newSyntacticForm);
10242 if (result.isInvalid()) return ExprError();
10243
10244 // If that gives us a pseudo-object result back, the pseudo-object
10245 // expression must have been an lvalue-to-rvalue conversion which we
10246 // should reapply.
10247 if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject))
10248 result = SemaRef.checkPseudoObjectRValue(result.get());
10249
10250 return result;
10251}
10252
10253template<typename Derived>
10254ExprResult
10255TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr(
10256 UnaryExprOrTypeTraitExpr *E) {
10257 if (E->isArgumentType()) {
10258 TypeSourceInfo *OldT = E->getArgumentTypeInfo();
10259
10260 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
10261 if (!NewT)
10262 return ExprError();
10263
10264 if (!getDerived().AlwaysRebuild() && OldT == NewT)
10265 return E;
10266
10267 return getDerived().RebuildUnaryExprOrTypeTrait(NewT, E->getOperatorLoc(),
10268 E->getKind(),
10269 E->getSourceRange());
10270 }
10271
10272 // C++0x [expr.sizeof]p1:
10273 // The operand is either an expression, which is an unevaluated operand
10274 // [...]
10275 EnterExpressionEvaluationContext Unevaluated(
10276 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated,
10277 Sema::ReuseLambdaContextDecl);
10278
10279 // Try to recover if we have something like sizeof(T::X) where X is a type.
10280 // Notably, there must be *exactly* one set of parens if X is a type.
10281 TypeSourceInfo *RecoveryTSI = nullptr;
10282 ExprResult SubExpr;
10283 auto *PE = dyn_cast<ParenExpr>(E->getArgumentExpr());
10284 if (auto *DRE =
10285 PE ? dyn_cast<DependentScopeDeclRefExpr>(PE->getSubExpr()) : nullptr)
10286 SubExpr = getDerived().TransformParenDependentScopeDeclRefExpr(
10287 PE, DRE, false, &RecoveryTSI);
10288 else
10289 SubExpr = getDerived().TransformExpr(E->getArgumentExpr());
10290
10291 if (RecoveryTSI) {
10292 return getDerived().RebuildUnaryExprOrTypeTrait(
10293 RecoveryTSI, E->getOperatorLoc(), E->getKind(), E->getSourceRange());
10294 } else if (SubExpr.isInvalid())
10295 return ExprError();
10296
10297 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr())
10298 return E;
10299
10300 return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(),
10301 E->getOperatorLoc(),
10302 E->getKind(),
10303 E->getSourceRange());
10304}
10305
10306template<typename Derived>
10307ExprResult
10308TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) {
10309 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
10310 if (LHS.isInvalid())
10311 return ExprError();
10312
10313 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
10314 if (RHS.isInvalid())
10315 return ExprError();
10316
10317
10318 if (!getDerived().AlwaysRebuild() &&
10319 LHS.get() == E->getLHS() &&
10320 RHS.get() == E->getRHS())
10321 return E;
10322
10323 return getDerived().RebuildArraySubscriptExpr(
10324 LHS.get(),
10325 /*FIXME:*/ E->getLHS()->getBeginLoc(), RHS.get(), E->getRBracketLoc());
10326}
10327
10328template <typename Derived>
10329ExprResult
10330TreeTransform<Derived>::TransformMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
10331 ExprResult Base = getDerived().TransformExpr(E->getBase());
10332 if (Base.isInvalid())
10333 return ExprError();
10334
10335 ExprResult RowIdx = getDerived().TransformExpr(E->getRowIdx());
10336 if (RowIdx.isInvalid())
10337 return ExprError();
10338
10339 ExprResult ColumnIdx = getDerived().TransformExpr(E->getColumnIdx());
10340 if (ColumnIdx.isInvalid())
10341 return ExprError();
10342
10343 if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() &&
10344 RowIdx.get() == E->getRowIdx() && ColumnIdx.get() == E->getColumnIdx())
10345 return E;
10346
10347 return getDerived().RebuildMatrixSubscriptExpr(
10348 Base.get(), RowIdx.get(), ColumnIdx.get(), E->getRBracketLoc());
10349}
10350
10351template <typename Derived>
10352ExprResult
10353TreeTransform<Derived>::TransformOMPArraySectionExpr(OMPArraySectionExpr *E) {
10354 ExprResult Base = getDerived().TransformExpr(E->getBase());
10355 if (Base.isInvalid())
10356 return ExprError();
10357
10358 ExprResult LowerBound;
10359 if (E->getLowerBound()) {
10360 LowerBound = getDerived().TransformExpr(E->getLowerBound());
10361 if (LowerBound.isInvalid())
10362 return ExprError();
10363 }
10364
10365 ExprResult Length;
10366 if (E->getLength()) {
10367 Length = getDerived().TransformExpr(E->getLength());
10368 if (Length.isInvalid())
10369 return ExprError();
10370 }
10371
10372 ExprResult Stride;
10373 if (Expr *Str = E->getStride()) {
10374 Stride = getDerived().TransformExpr(Str);
10375 if (Stride.isInvalid())
10376 return ExprError();
10377 }
10378
10379 if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() &&
10380 LowerBound.get() == E->getLowerBound() && Length.get() == E->getLength())
10381 return E;
10382
10383 return getDerived().RebuildOMPArraySectionExpr(
10384 Base.get(), E->getBase()->getEndLoc(), LowerBound.get(),
10385 E->getColonLocFirst(), E->getColonLocSecond(), Length.get(), Stride.get(),
10386 E->getRBracketLoc());
10387}
10388
10389template <typename Derived>
10390ExprResult
10391TreeTransform<Derived>::TransformOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
10392 ExprResult Base = getDerived().TransformExpr(E->getBase());
10393 if (Base.isInvalid())
10394 return ExprError();
10395
10396 SmallVector<Expr *, 4> Dims;
10397 bool ErrorFound = false;
10398 for (Expr *Dim : E->getDimensions()) {
10399 ExprResult DimRes = getDerived().TransformExpr(Dim);
10400 if (DimRes.isInvalid()) {
10401 ErrorFound = true;
10402 continue;
10403 }
10404 Dims.push_back(DimRes.get());
10405 }
10406
10407 if (ErrorFound)
10408 return ExprError();
10409 return getDerived().RebuildOMPArrayShapingExpr(Base.get(), E->getLParenLoc(),
10410 E->getRParenLoc(), Dims,
10411 E->getBracketsRanges());
10412}
10413
10414template <typename Derived>
10415ExprResult
10416TreeTransform<Derived>::TransformOMPIteratorExpr(OMPIteratorExpr *E) {
10417 unsigned NumIterators = E->numOfIterators();
10418 SmallVector<Sema::OMPIteratorData, 4> Data(NumIterators);
10419
10420 bool ErrorFound = false;
10421 bool NeedToRebuild = getDerived().AlwaysRebuild();
10422 for (unsigned I = 0; I < NumIterators; ++I) {
10423 auto *D = cast<VarDecl>(E->getIteratorDecl(I));
10424 Data[I].DeclIdent = D->getIdentifier();
10425 Data[I].DeclIdentLoc = D->getLocation();
10426 if (D->getLocation() == D->getBeginLoc()) {
10427 assert(SemaRef.Context.hasSameType(D->getType(), SemaRef.Context.IntTy) &&
10428 "Implicit type must be int.");
10429 } else {
10430 TypeSourceInfo *TSI = getDerived().TransformType(D->getTypeSourceInfo());
10431 QualType DeclTy = getDerived().TransformType(D->getType());
10432 Data[I].Type = SemaRef.CreateParsedType(DeclTy, TSI);
10433 }
10434 OMPIteratorExpr::IteratorRange Range = E->getIteratorRange(I);
10435 ExprResult Begin = getDerived().TransformExpr(Range.Begin);
10436 ExprResult End = getDerived().TransformExpr(Range.End);
10437 ExprResult Step = getDerived().TransformExpr(Range.Step);
10438 ErrorFound = ErrorFound ||
10439 !(!D->getTypeSourceInfo() || (Data[I].Type.getAsOpaquePtr() &&
10440 !Data[I].Type.get().isNull())) ||
10441 Begin.isInvalid() || End.isInvalid() || Step.isInvalid();
10442 if (ErrorFound)
10443 continue;
10444 Data[I].Range.Begin = Begin.get();
10445 Data[I].Range.End = End.get();
10446 Data[I].Range.Step = Step.get();
10447 Data[I].AssignLoc = E->getAssignLoc(I);
10448 Data[I].ColonLoc = E->getColonLoc(I);
10449 Data[I].SecColonLoc = E->getSecondColonLoc(I);
10450 NeedToRebuild =
10451 NeedToRebuild ||
10452 (D->getTypeSourceInfo() && Data[I].Type.get().getTypePtrOrNull() !=
10453 D->getType().getTypePtrOrNull()) ||
10454 Range.Begin != Data[I].Range.Begin || Range.End != Data[I].Range.End ||
10455 Range.Step != Data[I].Range.Step;
10456 }
10457 if (ErrorFound)
10458 return ExprError();
10459 if (!NeedToRebuild)
10460 return E;
10461
10462 ExprResult Res = getDerived().RebuildOMPIteratorExpr(
10463 E->getIteratorKwLoc(), E->getLParenLoc(), E->getRParenLoc(), Data);
10464 if (!Res.isUsable())
10465 return Res;
10466 auto *IE = cast<OMPIteratorExpr>(Res.get());
10467 for (unsigned I = 0; I < NumIterators; ++I)
10468 getDerived().transformedLocalDecl(E->getIteratorDecl(I),
10469 IE->getIteratorDecl(I));
10470 return Res;
10471}
10472
10473template<typename Derived>
10474ExprResult
10475TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
10476 // Transform the callee.
10477 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
10478 if (Callee.isInvalid())
10479 return ExprError();
10480
10481 // Transform arguments.
10482 bool ArgChanged = false;
10483 SmallVector<Expr*, 8> Args;
10484 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
10485 &ArgChanged))
10486 return ExprError();
10487
10488 if (!getDerived().AlwaysRebuild() &&
10489 Callee.get() == E->getCallee() &&
10490 !ArgChanged)
10491 return SemaRef.MaybeBindToTemporary(E);
10492
10493 // FIXME: Wrong source location information for the '('.
10494 SourceLocation FakeLParenLoc
10495 = ((Expr *)Callee.get())->getSourceRange().getBegin();
10496
10497 Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
10498 if (E->hasStoredFPFeatures()) {
10499 FPOptionsOverride NewOverrides = E->getFPFeatures();
10500 getSema().CurFPFeatures =
10501 NewOverrides.applyOverrides(getSema().getLangOpts());
10502 getSema().FpPragmaStack.CurrentValue = NewOverrides;
10503 }
10504
10505 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
10506 Args,
10507 E->getRParenLoc());
10508}
10509
10510template<typename Derived>
10511ExprResult
10512TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
10513 ExprResult Base = getDerived().TransformExpr(E->getBase());
10514 if (Base.isInvalid())
10515 return ExprError();
10516
10517 NestedNameSpecifierLoc QualifierLoc;
10518 if (E->hasQualifier()) {
10519 QualifierLoc
10520 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
10521
10522 if (!QualifierLoc)
10523 return ExprError();
10524 }
10525 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
10526
10527 ValueDecl *Member
10528 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(),
10529 E->getMemberDecl()));
10530 if (!Member)
10531 return ExprError();
10532
10533 NamedDecl *FoundDecl = E->getFoundDecl();
10534 if (FoundDecl == E->getMemberDecl()) {
10535 FoundDecl = Member;
10536 } else {
10537 FoundDecl = cast_or_null<NamedDecl>(
10538 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl));
10539 if (!FoundDecl)
10540 return ExprError();
10541 }
10542
10543 if (!getDerived().AlwaysRebuild() &&
10544 Base.get() == E->getBase() &&
10545 QualifierLoc == E->getQualifierLoc() &&
10546 Member == E->getMemberDecl() &&
10547 FoundDecl == E->getFoundDecl() &&
10548 !E->hasExplicitTemplateArgs()) {
10549
10550 // Mark it referenced in the new context regardless.
10551 // FIXME: this is a bit instantiation-specific.
10552 SemaRef.MarkMemberReferenced(E);
10553
10554 return E;
10555 }
10556
10557 TemplateArgumentListInfo TransArgs;
10558 if (E->hasExplicitTemplateArgs()) {
10559 TransArgs.setLAngleLoc(E->getLAngleLoc());
10560 TransArgs.setRAngleLoc(E->getRAngleLoc());
10561 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
10562 E->getNumTemplateArgs(),
10563 TransArgs))
10564 return ExprError();
10565 }
10566
10567 // FIXME: Bogus source location for the operator
10568 SourceLocation FakeOperatorLoc =
10569 SemaRef.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd());
10570
10571 // FIXME: to do this check properly, we will need to preserve the
10572 // first-qualifier-in-scope here, just in case we had a dependent
10573 // base (and therefore couldn't do the check) and a
10574 // nested-name-qualifier (and therefore could do the lookup).
10575 NamedDecl *FirstQualifierInScope = nullptr;
10576 DeclarationNameInfo MemberNameInfo = E->getMemberNameInfo();
10577 if (MemberNameInfo.getName()) {
10578 MemberNameInfo = getDerived().TransformDeclarationNameInfo(MemberNameInfo);
10579 if (!MemberNameInfo.getName())
10580 return ExprError();
10581 }
10582
10583 return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc,
10584 E->isArrow(),
10585 QualifierLoc,
10586 TemplateKWLoc,
10587 MemberNameInfo,
10588 Member,
10589 FoundDecl,
10590 (E->hasExplicitTemplateArgs()
10591 ? &TransArgs : nullptr),
10592 FirstQualifierInScope);
10593}
10594
10595template<typename Derived>
10596ExprResult
10597TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
10598 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
10599 if (LHS.isInvalid())
10600 return ExprError();
10601
10602 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
10603 if (RHS.isInvalid())
10604 return ExprError();
10605
10606 if (!getDerived().AlwaysRebuild() &&
10607 LHS.get() == E->getLHS() &&
10608 RHS.get() == E->getRHS())
10609 return E;
10610
10611 if (E->isCompoundAssignmentOp())
10612 // FPFeatures has already been established from trailing storage
10613 return getDerived().RebuildBinaryOperator(
10614 E->getOperatorLoc(), E->getOpcode(), LHS.get(), RHS.get());
10615 Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
10616 FPOptionsOverride NewOverrides(E->getFPFeatures(getSema().getLangOpts()));
10617 getSema().CurFPFeatures =
10618 NewOverrides.applyOverrides(getSema().getLangOpts());
10619 getSema().FpPragmaStack.CurrentValue = NewOverrides;
10620 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(),
10621 LHS.get(), RHS.get());
10622}
10623
10624template <typename Derived>
10625ExprResult TreeTransform<Derived>::TransformCXXRewrittenBinaryOperator(
10626 CXXRewrittenBinaryOperator *E) {
10627 CXXRewrittenBinaryOperator::DecomposedForm Decomp = E->getDecomposedForm();
10628
10629 ExprResult LHS = getDerived().TransformExpr(const_cast<Expr*>(Decomp.LHS));
10630 if (LHS.isInvalid())
10631 return ExprError();
10632
10633 ExprResult RHS = getDerived().TransformExpr(const_cast<Expr*>(Decomp.RHS));
10634 if (RHS.isInvalid())
10635 return ExprError();
10636
10637 if (!getDerived().AlwaysRebuild() &&
10638 LHS.get() == Decomp.LHS &&
10639 RHS.get() == Decomp.RHS)
10640 return E;
10641
10642 // Extract the already-resolved callee declarations so that we can restrict
10643 // ourselves to using them as the unqualified lookup results when rebuilding.
10644 UnresolvedSet<2> UnqualLookups;
10645 Expr *PossibleBinOps[] = {E->getSemanticForm(),
10646 const_cast<Expr *>(Decomp.InnerBinOp)};
10647 for (Expr *PossibleBinOp : PossibleBinOps) {
10648 auto *Op = dyn_cast<CXXOperatorCallExpr>(PossibleBinOp->IgnoreImplicit());
10649 if (!Op)
10650 continue;
10651 auto *Callee = dyn_cast<DeclRefExpr>(Op->getCallee()->IgnoreImplicit());
10652 if (!Callee || isa<CXXMethodDecl>(Callee->getDecl()))
10653 continue;
10654
10655 // Transform the callee in case we built a call to a local extern
10656 // declaration.
10657 NamedDecl *Found = cast_or_null<NamedDecl>(getDerived().TransformDecl(
10658 E->getOperatorLoc(), Callee->getFoundDecl()));
10659 if (!Found)
10660 return ExprError();
10661 UnqualLookups.addDecl(Found);
10662 }
10663
10664 return getDerived().RebuildCXXRewrittenBinaryOperator(
10665 E->getOperatorLoc(), Decomp.Opcode, UnqualLookups, LHS.get(), RHS.get());
10666}
10667
10668template<typename Derived>
10669ExprResult
10670TreeTransform<Derived>::TransformCompoundAssignOperator(
10671 CompoundAssignOperator *E) {
10672 Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
10673 FPOptionsOverride NewOverrides(E->getFPFeatures(getSema().getLangOpts()));
10674 getSema().CurFPFeatures =
10675 NewOverrides.applyOverrides(getSema().getLangOpts());
10676 getSema().FpPragmaStack.CurrentValue = NewOverrides;
10677 return getDerived().TransformBinaryOperator(E);
10678}
10679
10680template<typename Derived>
10681ExprResult TreeTransform<Derived>::
10682TransformBinaryConditionalOperator(BinaryConditionalOperator *e) {
10683 // Just rebuild the common and RHS expressions and see whether we
10684 // get any changes.
10685
10686 ExprResult commonExpr = getDerived().TransformExpr(e->getCommon());
10687 if (commonExpr.isInvalid())
10688 return ExprError();
10689
10690 ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr());
10691 if (rhs.isInvalid())
10692 return ExprError();
10693
10694 if (!getDerived().AlwaysRebuild() &&
10695 commonExpr.get() == e->getCommon() &&
10696 rhs.get() == e->getFalseExpr())
10697 return e;
10698
10699 return getDerived().RebuildConditionalOperator(commonExpr.get(),
10700 e->getQuestionLoc(),
10701 nullptr,
10702 e->getColonLoc(),
10703 rhs.get());
10704}
10705
10706template<typename Derived>
10707ExprResult
10708TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) {
10709 ExprResult Cond = getDerived().TransformExpr(E->getCond());
10710 if (Cond.isInvalid())
10711 return ExprError();
10712
10713 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
10714 if (LHS.isInvalid())
10715 return ExprError();
10716
10717 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
10718 if (RHS.isInvalid())
10719 return ExprError();
10720
10721 if (!getDerived().AlwaysRebuild() &&
10722 Cond.get() == E->getCond() &&
10723 LHS.get() == E->getLHS() &&
10724 RHS.get() == E->getRHS())
10725 return E;
10726
10727 return getDerived().RebuildConditionalOperator(Cond.get(),
10728 E->getQuestionLoc(),
10729 LHS.get(),
10730 E->getColonLoc(),
10731 RHS.get());
10732}
10733
10734template<typename Derived>
10735ExprResult
10736TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) {
10737 // Implicit casts are eliminated during transformation, since they
10738 // will be recomputed by semantic analysis after transformation.
10739 return getDerived().TransformExpr(E->getSubExprAsWritten());
10740}
10741
10742template<typename Derived>
10743ExprResult
10744TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) {
10745 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
10746 if (!Type)
10747 return ExprError();
10748
10749 ExprResult SubExpr
10750 = getDerived().TransformExpr(E->getSubExprAsWritten());
10751 if (SubExpr.isInvalid())
10752 return ExprError();
10753
10754 if (!getDerived().AlwaysRebuild() &&
10755 Type == E->getTypeInfoAsWritten() &&
10756 SubExpr.get() == E->getSubExpr())
10757 return E;
10758
10759 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(),
10760 Type,
10761 E->getRParenLoc(),
10762 SubExpr.get());
10763}
10764
10765template<typename Derived>
10766ExprResult
10767TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) {
10768 TypeSourceInfo *OldT = E->getTypeSourceInfo();
10769 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
10770 if (!NewT)
10771 return ExprError();
10772
10773 ExprResult Init = getDerived().TransformExpr(E->getInitializer());
10774 if (Init.isInvalid())
10775 return ExprError();
10776
10777 if (!getDerived().AlwaysRebuild() &&
10778 OldT == NewT &&
10779 Init.get() == E->getInitializer())
10780 return SemaRef.MaybeBindToTemporary(E);
10781
10782 // Note: the expression type doesn't necessarily match the
10783 // type-as-written, but that's okay, because it should always be
10784 // derivable from the initializer.
10785
10786 return getDerived().RebuildCompoundLiteralExpr(
10787 E->getLParenLoc(), NewT,
10788 /*FIXME:*/ E->getInitializer()->getEndLoc(), Init.get());
10789}
10790
10791template<typename Derived>
10792ExprResult
10793TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) {
10794 ExprResult Base = getDerived().TransformExpr(E->getBase());
10795 if (Base.isInvalid())
10796 return ExprError();
10797
10798 if (!getDerived().AlwaysRebuild() &&
10799 Base.get() == E->getBase())
10800 return E;
10801
10802 // FIXME: Bad source location
10803 SourceLocation FakeOperatorLoc =
10804 SemaRef.getLocForEndOfToken(E->getBase()->getEndLoc());
10805 return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc,
10806 E->getAccessorLoc(),
10807 E->getAccessor());
10808}
10809
10810template<typename Derived>
10811ExprResult
10812TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) {
10813 if (InitListExpr *Syntactic = E->getSyntacticForm())
10814 E = Syntactic;
10815
10816 bool InitChanged = false;
10817
10818 EnterExpressionEvaluationContext Context(
10819 getSema(), EnterExpressionEvaluationContext::InitList);
10820
10821 SmallVector<Expr*, 4> Inits;
10822 if (getDerived().TransformExprs(E->getInits(), E->getNumInits(), false,
10823 Inits, &InitChanged))
10824 return ExprError();
10825
10826 if (!getDerived().AlwaysRebuild() && !InitChanged) {
10827 // FIXME: Attempt to reuse the existing syntactic form of the InitListExpr
10828 // in some cases. We can't reuse it in general, because the syntactic and
10829 // semantic forms are linked, and we can't know that semantic form will
10830 // match even if the syntactic form does.
10831 }
10832
10833 return getDerived().RebuildInitList(E->getLBraceLoc(), Inits,
10834 E->getRBraceLoc());
10835}
10836
10837template<typename Derived>
10838ExprResult
10839TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) {
10840 Designation Desig;
10841
10842 // transform the initializer value
10843 ExprResult Init = getDerived().TransformExpr(E->getInit());
10844 if (Init.isInvalid())
10845 return ExprError();
10846
10847 // transform the designators.
10848 SmallVector<Expr*, 4> ArrayExprs;
10849 bool ExprChanged = false;
10850 for (const DesignatedInitExpr::Designator &D : E->designators()) {
10851 if (D.isFieldDesignator()) {
10852 Desig.AddDesignator(Designator::getField(D.getFieldName(),
10853 D.getDotLoc(),
10854 D.getFieldLoc()));
10855 if (D.getField()) {
10856 FieldDecl *Field = cast_or_null<FieldDecl>(
10857 getDerived().TransformDecl(D.getFieldLoc(), D.getField()));
10858 if (Field != D.getField())
10859 // Rebuild the expression when the transformed FieldDecl is
10860 // different to the already assigned FieldDecl.
10861 ExprChanged = true;
10862 } else {
10863 // Ensure that the designator expression is rebuilt when there isn't
10864 // a resolved FieldDecl in the designator as we don't want to assign
10865 // a FieldDecl to a pattern designator that will be instantiated again.
10866 ExprChanged = true;
10867 }
10868 continue;
10869 }
10870
10871 if (D.isArrayDesignator()) {
10872 ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(D));
10873 if (Index.isInvalid())
10874 return ExprError();
10875
10876 Desig.AddDesignator(
10877 Designator::getArray(Index.get(), D.getLBracketLoc()));
10878
10879 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(D);
10880 ArrayExprs.push_back(Index.get());
10881 continue;
10882 }
10883
10884 assert(D.isArrayRangeDesignator() && "New kind of designator?");
10885 ExprResult Start
10886 = getDerived().TransformExpr(E->getArrayRangeStart(D));
10887 if (Start.isInvalid())
10888 return ExprError();
10889
10890 ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(D));
10891 if (End.isInvalid())
10892 return ExprError();
10893
10894 Desig.AddDesignator(Designator::getArrayRange(Start.get(),
10895 End.get(),
10896 D.getLBracketLoc(),
10897 D.getEllipsisLoc()));
10898
10899 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(D) ||
10900 End.get() != E->getArrayRangeEnd(D);
10901
10902 ArrayExprs.push_back(Start.get());
10903 ArrayExprs.push_back(End.get());
10904 }
10905
10906 if (!getDerived().AlwaysRebuild() &&
10907 Init.get() == E->getInit() &&
10908 !ExprChanged)
10909 return E;
10910
10911 return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs,
10912 E->getEqualOrColonLoc(),
10913 E->usesGNUSyntax(), Init.get());
10914}
10915
10916// Seems that if TransformInitListExpr() only works on the syntactic form of an
10917// InitListExpr, then a DesignatedInitUpdateExpr is not encountered.
10918template<typename Derived>
10919ExprResult
10920TreeTransform<Derived>::TransformDesignatedInitUpdateExpr(
10921 DesignatedInitUpdateExpr *E) {
10922 llvm_unreachable("Unexpected DesignatedInitUpdateExpr in syntactic form of "
10923 "initializer");
10924 return ExprError();
10925}
10926
10927template<typename Derived>
10928ExprResult
10929TreeTransform<Derived>::TransformNoInitExpr(
10930 NoInitExpr *E) {
10931 llvm_unreachable("Unexpected NoInitExpr in syntactic form of initializer");
10932 return ExprError();
10933}
10934
10935template<typename Derived>
10936ExprResult
10937TreeTransform<Derived>::TransformArrayInitLoopExpr(ArrayInitLoopExpr *E) {
10938 llvm_unreachable("Unexpected ArrayInitLoopExpr outside of initializer");
10939 return ExprError();
10940}
10941
10942template<typename Derived>
10943ExprResult
10944TreeTransform<Derived>::TransformArrayInitIndexExpr(ArrayInitIndexExpr *E) {
10945 llvm_unreachable("Unexpected ArrayInitIndexExpr outside of initializer");
10946 return ExprError();
10947}
10948
10949template<typename Derived>
10950ExprResult
10951TreeTransform<Derived>::TransformImplicitValueInitExpr(
10952 ImplicitValueInitExpr *E) {
10953 TemporaryBase Rebase(*this, E->getBeginLoc(), DeclarationName());
10954
10955 // FIXME: Will we ever have proper type location here? Will we actually
10956 // need to transform the type?
10957 QualType T = getDerived().TransformType(E->getType());
10958 if (T.isNull())
10959 return ExprError();
10960
10961 if (!getDerived().AlwaysRebuild() &&
10962 T == E->getType())
10963 return E;
10964
10965 return getDerived().RebuildImplicitValueInitExpr(T);
10966}
10967
10968template<typename Derived>
10969ExprResult
10970TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) {
10971 TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo());
10972 if (!TInfo)
10973 return ExprError();
10974
10975 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
10976 if (SubExpr.isInvalid())
10977 return ExprError();
10978
10979 if (!getDerived().AlwaysRebuild() &&
10980 TInfo == E->getWrittenTypeInfo() &&
10981 SubExpr.get() == E->getSubExpr())
10982 return E;
10983
10984 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(),
10985 TInfo, E->getRParenLoc());
10986}
10987
10988template<typename Derived>
10989ExprResult
10990TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) {
10991 bool ArgumentChanged = false;
10992 SmallVector<Expr*, 4> Inits;
10993 if (TransformExprs(E->getExprs(), E->getNumExprs(), true, Inits,
10994 &ArgumentChanged))
10995 return ExprError();
10996
10997 return getDerived().RebuildParenListExpr(E->getLParenLoc(),
10998 Inits,
10999 E->getRParenLoc());
11000}
11001
11002/// Transform an address-of-label expression.
11003///
11004/// By default, the transformation of an address-of-label expression always
11005/// rebuilds the expression, so that the label identifier can be resolved to
11006/// the corresponding label statement by semantic analysis.
11007template<typename Derived>
11008ExprResult
11009TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) {
11010 Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(),
11011 E->getLabel());
11012 if (!LD)
11013 return ExprError();
11014
11015 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(),
11016 cast<LabelDecl>(LD));
11017}
11018
11019template<typename Derived>
11020ExprResult
11021TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) {
11022 SemaRef.ActOnStartStmtExpr();
11023 StmtResult SubStmt
11024 = getDerived().TransformCompoundStmt(E->getSubStmt(), true);
11025 if (SubStmt.isInvalid()) {
11026 SemaRef.ActOnStmtExprError();
11027 return ExprError();
11028 }
11029
11030 unsigned OldDepth = E->getTemplateDepth();
11031 unsigned NewDepth = getDerived().TransformTemplateDepth(OldDepth);
11032
11033 if (!getDerived().AlwaysRebuild() && OldDepth == NewDepth &&
11034 SubStmt.get() == E->getSubStmt()) {
11035 // Calling this an 'error' is unintuitive, but it does the right thing.
11036 SemaRef.ActOnStmtExprError();
11037 return SemaRef.MaybeBindToTemporary(E);
11038 }
11039
11040 return getDerived().RebuildStmtExpr(E->getLParenLoc(), SubStmt.get(),
11041 E->getRParenLoc(), NewDepth);
11042}
11043
11044template<typename Derived>
11045ExprResult
11046TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) {
11047 ExprResult Cond = getDerived().TransformExpr(E->getCond());
11048 if (Cond.isInvalid())
11049 return ExprError();
11050
11051 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
11052 if (LHS.isInvalid())
11053 return ExprError();
11054
11055 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
11056 if (RHS.isInvalid())
11057 return ExprError();
11058
11059 if (!getDerived().AlwaysRebuild() &&
11060 Cond.get() == E->getCond() &&
11061 LHS.get() == E->getLHS() &&
11062 RHS.get() == E->getRHS())
11063 return E;
11064
11065 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(),
11066 Cond.get(), LHS.get(), RHS.get(),
11067 E->getRParenLoc());
11068}
11069
11070template<typename Derived>
11071ExprResult
11072TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) {
11073 return E;
11074}
11075
11076template<typename Derived>
11077ExprResult
11078TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
11079 switch (E->getOperator()) {
11080 case OO_New:
11081 case OO_Delete:
11082 case OO_Array_New:
11083 case OO_Array_Delete:
11084 llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr");
11085
11086 case OO_Call: {
11087 // This is a call to an object's operator().
11088 assert(E->getNumArgs() >= 1 && "Object call is missing arguments");
11089
11090 // Transform the object itself.
11091 ExprResult Object = getDerived().TransformExpr(E->getArg(0));
11092 if (Object.isInvalid())
11093 return ExprError();
11094
11095 // FIXME: Poor location information
11096 SourceLocation FakeLParenLoc = SemaRef.getLocForEndOfToken(
11097 static_cast<Expr *>(Object.get())->getEndLoc());
11098
11099 // Transform the call arguments.
11100 SmallVector<Expr*, 8> Args;
11101 if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1, true,
11102 Args))
11103 return ExprError();
11104
11105 return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc, Args,
11106 E->getEndLoc());
11107 }
11108
11109#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
11110 case OO_##Name:
11111#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
11112#include "clang/Basic/OperatorKinds.def"
11113 case OO_Subscript:
11114 // Handled below.
11115 break;
11116
11117 case OO_Conditional:
11118 llvm_unreachable("conditional operator is not actually overloadable");
11119
11120 case OO_None:
11121 case NUM_OVERLOADED_OPERATORS:
11122 llvm_unreachable("not an overloaded operator?");
11123 }
11124
11125 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
11126 if (Callee.isInvalid())
11127 return ExprError();
11128
11129 ExprResult First;
11130 if (E->getOperator() == OO_Amp)
11131 First = getDerived().TransformAddressOfOperand(E->getArg(0));
11132 else
11133 First = getDerived().TransformExpr(E->getArg(0));
11134 if (First.isInvalid())
11135 return ExprError();
11136
11137 ExprResult Second;
11138 if (E->getNumArgs() == 2) {
11139 Second = getDerived().TransformExpr(E->getArg(1));
11140 if (Second.isInvalid())
11141 return ExprError();
11142 }
11143
11144 if (!getDerived().AlwaysRebuild() &&
11145 Callee.get() == E->getCallee() &&
11146 First.get() == E->getArg(0) &&
11147 (E->getNumArgs() != 2 || Second.get() == E->getArg(1)))
11148 return SemaRef.MaybeBindToTemporary(E);
11149
11150 Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
11151 FPOptionsOverride NewOverrides(E->getFPFeatures());
11152 getSema().CurFPFeatures =
11153 NewOverrides.applyOverrides(getSema().getLangOpts());
11154 getSema().FpPragmaStack.CurrentValue = NewOverrides;
11155
11156 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(),
11157 E->getOperatorLoc(),
11158 Callee.get(),
11159 First.get(),
11160 Second.get());
11161}
11162
11163template<typename Derived>
11164ExprResult
11165TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) {
11166 return getDerived().TransformCallExpr(E);
11167}
11168
11169template <typename Derived>
11170ExprResult TreeTransform<Derived>::TransformSourceLocExpr(SourceLocExpr *E) {
11171 bool NeedRebuildFunc = E->getIdentKind() == SourceLocExpr::Function &&
11172 getSema().CurContext != E->getParentContext();
11173
11174 if (!getDerived().AlwaysRebuild() && !NeedRebuildFunc)
11175 return E;
11176
11177 return getDerived().RebuildSourceLocExpr(E->getIdentKind(), E->getBeginLoc(),
11178 E->getEndLoc(),
11179 getSema().CurContext);
11180}
11181
11182template<typename Derived>
11183ExprResult
11184TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
11185 // Transform the callee.
11186 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
11187 if (Callee.isInvalid())
11188 return ExprError();
11189
11190 // Transform exec config.
11191 ExprResult EC = getDerived().TransformCallExpr(E->getConfig());
11192 if (EC.isInvalid())
11193 return ExprError();
11194
11195 // Transform arguments.
11196 bool ArgChanged = false;
11197 SmallVector<Expr*, 8> Args;
11198 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
11199 &ArgChanged))
11200 return ExprError();
11201
11202 if (!getDerived().AlwaysRebuild() &&
11203 Callee.get() == E->getCallee() &&
11204 !ArgChanged)
11205 return SemaRef.MaybeBindToTemporary(E);
11206
11207 // FIXME: Wrong source location information for the '('.
11208 SourceLocation FakeLParenLoc
11209 = ((Expr *)Callee.get())->getSourceRange().getBegin();
11210 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
11211 Args,
11212 E->getRParenLoc(), EC.get());
11213}
11214
11215template<typename Derived>
11216ExprResult
11217TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) {
11218 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
11219 if (!Type)
11220 return ExprError();
11221
11222 ExprResult SubExpr
11223 = getDerived().TransformExpr(E->getSubExprAsWritten());
11224 if (SubExpr.isInvalid())
11225 return ExprError();
11226
11227 if (!getDerived().AlwaysRebuild() &&
11228 Type == E->getTypeInfoAsWritten() &&
11229 SubExpr.get() == E->getSubExpr())
11230 return E;
11231 return getDerived().RebuildCXXNamedCastExpr(
11232 E->getOperatorLoc(), E->getStmtClass(), E->getAngleBrackets().getBegin(),
11233 Type, E->getAngleBrackets().getEnd(),
11234 // FIXME. this should be '(' location
11235 E->getAngleBrackets().getEnd(), SubExpr.get(), E->getRParenLoc());
11236}
11237
11238template<typename Derived>
11239ExprResult
11240TreeTransform<Derived>::TransformBuiltinBitCastExpr(BuiltinBitCastExpr *BCE) {
11241 TypeSourceInfo *TSI =
11242 getDerived().TransformType(BCE->getTypeInfoAsWritten());
11243 if (!TSI)
11244 return ExprError();
11245
11246 ExprResult Sub = getDerived().TransformExpr(BCE->getSubExpr());
11247 if (Sub.isInvalid())
11248 return ExprError();
11249
11250 return getDerived().RebuildBuiltinBitCastExpr(BCE->getBeginLoc(), TSI,
11251 Sub.get(), BCE->getEndLoc());
11252}
11253
11254template<typename Derived>
11255ExprResult
11256TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) {
11257 return getDerived().TransformCXXNamedCastExpr(E);
11258}
11259
11260template<typename Derived>
11261ExprResult
11262TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
11263 return getDerived().TransformCXXNamedCastExpr(E);
11264}
11265
11266template<typename Derived>
11267ExprResult
11268TreeTransform<Derived>::TransformCXXReinterpretCastExpr(
11269 CXXReinterpretCastExpr *E) {
11270 return getDerived().TransformCXXNamedCastExpr(E);
11271}
11272
11273template<typename Derived>
11274ExprResult
11275TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) {
11276 return getDerived().TransformCXXNamedCastExpr(E);
11277}
11278
11279template<typename Derived>
11280ExprResult
11281TreeTransform<Derived>::TransformCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) {
11282 return getDerived().TransformCXXNamedCastExpr(E);
11283}
11284
11285template<typename Derived>
11286ExprResult
11287TreeTransform<Derived>::TransformCXXFunctionalCastExpr(
11288 CXXFunctionalCastExpr *E) {
11289 TypeSourceInfo *Type =
11290 getDerived().TransformTypeWithDeducedTST(E->getTypeInfoAsWritten());
11291 if (!Type)
11292 return ExprError();
11293
11294 ExprResult SubExpr
11295 = getDerived().TransformExpr(E->getSubExprAsWritten());
11296 if (SubExpr.isInvalid())
11297 return ExprError();
11298
11299 if (!getDerived().AlwaysRebuild() &&
11300 Type == E->getTypeInfoAsWritten() &&
11301 SubExpr.get() == E->getSubExpr())
11302 return E;
11303
11304 return getDerived().RebuildCXXFunctionalCastExpr(Type,
11305 E->getLParenLoc(),
11306 SubExpr.get(),
11307 E->getRParenLoc(),
11308 E->isListInitialization());
11309}
11310
11311template<typename Derived>
11312ExprResult
11313TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) {
11314 if (E->isTypeOperand()) {
11315 TypeSourceInfo *TInfo
11316 = getDerived().TransformType(E->getTypeOperandSourceInfo());
11317 if (!TInfo)
11318 return ExprError();
11319
11320 if (!getDerived().AlwaysRebuild() &&
11321 TInfo == E->getTypeOperandSourceInfo())
11322 return E;
11323
11324 return getDerived().RebuildCXXTypeidExpr(E->getType(), E->getBeginLoc(),
11325 TInfo, E->getEndLoc());
11326 }
11327
11328 // We don't know whether the subexpression is potentially evaluated until
11329 // after we perform semantic analysis. We speculatively assume it is
11330 // unevaluated; it will get fixed later if the subexpression is in fact
11331 // potentially evaluated.
11332 EnterExpressionEvaluationContext Unevaluated(
11333 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated,
11334 Sema::ReuseLambdaContextDecl);
11335
11336 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
11337 if (SubExpr.isInvalid())
11338 return ExprError();
11339
11340 if (!getDerived().AlwaysRebuild() &&
11341 SubExpr.get() == E->getExprOperand())
11342 return E;
11343
11344 return getDerived().RebuildCXXTypeidExpr(E->getType(), E->getBeginLoc(),
11345 SubExpr.get(), E->getEndLoc());
11346}
11347
11348template<typename Derived>
11349ExprResult
11350TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) {
11351 if (E->isTypeOperand()) {
11352 TypeSourceInfo *TInfo
11353 = getDerived().TransformType(E->getTypeOperandSourceInfo());
11354 if (!TInfo)
11355 return ExprError();
11356
11357 if (!getDerived().AlwaysRebuild() &&
11358 TInfo == E->getTypeOperandSourceInfo())
11359 return E;
11360
11361 return getDerived().RebuildCXXUuidofExpr(E->getType(), E->getBeginLoc(),
11362 TInfo, E->getEndLoc());
11363 }
11364
11365 EnterExpressionEvaluationContext Unevaluated(
11366 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
11367
11368 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
11369 if (SubExpr.isInvalid())
11370 return ExprError();
11371
11372 if (!getDerived().AlwaysRebuild() &&
11373 SubExpr.get() == E->getExprOperand())
11374 return E;
11375
11376 return getDerived().RebuildCXXUuidofExpr(E->getType(), E->getBeginLoc(),
11377 SubExpr.get(), E->getEndLoc());
11378}
11379
11380template<typename Derived>
11381ExprResult
11382TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
11383 return E;
11384}
11385
11386template<typename Derived>
11387ExprResult
11388TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr(
11389 CXXNullPtrLiteralExpr *E) {
11390 return E;
11391}
11392
11393template<typename Derived>
11394ExprResult
11395TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) {
11396 QualType T = getSema().getCurrentThisType();
11397
11398 if (!getDerived().AlwaysRebuild() && T == E->getType()) {
11399 // Mark it referenced in the new context regardless.
11400 // FIXME: this is a bit instantiation-specific.
11401 getSema().MarkThisReferenced(E);
11402 return E;
11403 }
11404
11405 return getDerived().RebuildCXXThisExpr(E->getBeginLoc(), T, E->isImplicit());
11406}
11407
11408template<typename Derived>
11409ExprResult
11410TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) {
11411 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
11412 if (SubExpr.isInvalid())
11413 return ExprError();
11414
11415 if (!getDerived().AlwaysRebuild() &&
11416 SubExpr.get() == E->getSubExpr())
11417 return E;
11418
11419 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get(),
11420 E->isThrownVariableInScope());
11421}
11422
11423template<typename Derived>
11424ExprResult
11425TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
11426 ParmVarDecl *Param = cast_or_null<ParmVarDecl>(
11427 getDerived().TransformDecl(E->getBeginLoc(), E->getParam()));
11428 if (!Param)
11429 return ExprError();
11430
11431 if (!getDerived().AlwaysRebuild() && Param == E->getParam() &&
11432 E->getUsedContext() == SemaRef.CurContext)
11433 return E;
11434
11435 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param);
11436}
11437
11438template<typename Derived>
11439ExprResult
11440TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
11441 FieldDecl *Field = cast_or_null<FieldDecl>(
11442 getDerived().TransformDecl(E->getBeginLoc(), E->getField()));
11443 if (!Field)
11444 return ExprError();
11445
11446 if (!getDerived().AlwaysRebuild() && Field == E->getField() &&
11447 E->getUsedContext() == SemaRef.CurContext)
11448 return E;
11449
11450 return getDerived().RebuildCXXDefaultInitExpr(E->getExprLoc(), Field);
11451}
11452
11453template<typename Derived>
11454ExprResult
11455TreeTransform<Derived>::TransformCXXScalarValueInitExpr(
11456 CXXScalarValueInitExpr *E) {
11457 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
11458 if (!T)
11459 return ExprError();
11460
11461 if (!getDerived().AlwaysRebuild() &&
11462 T == E->getTypeSourceInfo())
11463 return E;
11464
11465 return getDerived().RebuildCXXScalarValueInitExpr(T,
11466 /*FIXME:*/T->getTypeLoc().getEndLoc(),
11467 E->getRParenLoc());
11468}
11469
11470template<typename Derived>
11471ExprResult
11472TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) {
11473 // Transform the type that we're allocating
11474 TypeSourceInfo *AllocTypeInfo =
11475 getDerived().TransformTypeWithDeducedTST(E->getAllocatedTypeSourceInfo());
11476 if (!AllocTypeInfo)
11477 return ExprError();
11478
11479 // Transform the size of the array we're allocating (if any).
11480 Optional<Expr *> ArraySize;
11481 if (Optional<Expr *> OldArraySize = E->getArraySize()) {
11482 ExprResult NewArraySize;
11483 if (*OldArraySize) {
11484 NewArraySize = getDerived().TransformExpr(*OldArraySize);
11485 if (NewArraySize.isInvalid())
11486 return ExprError();
11487 }
11488 ArraySize = NewArraySize.get();
11489 }
11490
11491 // Transform the placement arguments (if any).
11492 bool ArgumentChanged = false;
11493 SmallVector<Expr*, 8> PlacementArgs;
11494 if (getDerived().TransformExprs(E->getPlacementArgs(),
11495 E->getNumPlacementArgs(), true,
11496 PlacementArgs, &ArgumentChanged))
11497 return ExprError();
11498
11499 // Transform the initializer (if any).
11500 Expr *OldInit = E->getInitializer();
11501 ExprResult NewInit;
11502 if (OldInit)
11503 NewInit = getDerived().TransformInitializer(OldInit, true);
11504 if (NewInit.isInvalid())
11505 return ExprError();
11506
11507 // Transform new operator and delete operator.
11508 FunctionDecl *OperatorNew = nullptr;
11509 if (E->getOperatorNew()) {
11510 OperatorNew = cast_or_null<FunctionDecl>(
11511 getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorNew()));
11512 if (!OperatorNew)
11513 return ExprError();
11514 }
11515
11516 FunctionDecl *OperatorDelete = nullptr;
11517 if (E->getOperatorDelete()) {
11518 OperatorDelete = cast_or_null<FunctionDecl>(
11519 getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorDelete()));
11520 if (!OperatorDelete)
11521 return ExprError();
11522 }
11523
11524 if (!getDerived().AlwaysRebuild() &&
11525 AllocTypeInfo == E->getAllocatedTypeSourceInfo() &&
11526 ArraySize == E->getArraySize() &&
11527 NewInit.get() == OldInit &&
11528 OperatorNew == E->getOperatorNew() &&
11529 OperatorDelete == E->getOperatorDelete() &&
11530 !ArgumentChanged) {
11531 // Mark any declarations we need as referenced.
11532 // FIXME: instantiation-specific.
11533 if (OperatorNew)
11534 SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorNew);
11535 if (OperatorDelete)
11536 SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorDelete);
11537
11538 if (E->isArray() && !E->getAllocatedType()->isDependentType()) {
11539 QualType ElementType
11540 = SemaRef.Context.getBaseElementType(E->getAllocatedType());
11541 if (const RecordType *RecordT = ElementType->getAs<RecordType>()) {
11542 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordT->getDecl());
11543 if (CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(Record)) {
11544 SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Destructor);
11545 }
11546 }
11547 }
11548
11549 return E;
11550 }
11551
11552 QualType AllocType = AllocTypeInfo->getType();
11553 if (!ArraySize) {
11554 // If no array size was specified, but the new expression was
11555 // instantiated with an array type (e.g., "new T" where T is
11556 // instantiated with "int[4]"), extract the outer bound from the
11557 // array type as our array size. We do this with constant and
11558 // dependently-sized array types.
11559 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType);
11560 if (!ArrayT) {
11561 // Do nothing
11562 } else if (const ConstantArrayType *ConsArrayT
11563 = dyn_cast<ConstantArrayType>(ArrayT)) {
11564 ArraySize = IntegerLiteral::Create(SemaRef.Context, ConsArrayT->getSize(),
11565 SemaRef.Context.getSizeType(),
11566 /*FIXME:*/ E->getBeginLoc());
11567 AllocType = ConsArrayT->getElementType();
11568 } else if (const DependentSizedArrayType *DepArrayT
11569 = dyn_cast<DependentSizedArrayType>(ArrayT)) {
11570 if (DepArrayT->getSizeExpr()) {
11571 ArraySize = DepArrayT->getSizeExpr();
11572 AllocType = DepArrayT->getElementType();
11573 }
11574 }
11575 }
11576
11577 return getDerived().RebuildCXXNewExpr(
11578 E->getBeginLoc(), E->isGlobalNew(),
11579 /*FIXME:*/ E->getBeginLoc(), PlacementArgs,
11580 /*FIXME:*/ E->getBeginLoc(), E->getTypeIdParens(), AllocType,
11581 AllocTypeInfo, ArraySize, E->getDirectInitRange(), NewInit.get());
11582}
11583
11584template<typename Derived>
11585ExprResult
11586TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) {
11587 ExprResult Operand = getDerived().TransformExpr(E->getArgument());
11588 if (Operand.isInvalid())
11589 return ExprError();
11590
11591 // Transform the delete operator, if known.
11592 FunctionDecl *OperatorDelete = nullptr;
11593 if (E->getOperatorDelete()) {
11594 OperatorDelete = cast_or_null<FunctionDecl>(
11595 getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorDelete()));
11596 if (!OperatorDelete)
11597 return ExprError();
11598 }
11599
11600 if (!getDerived().AlwaysRebuild() &&
11601 Operand.get() == E->getArgument() &&
11602 OperatorDelete == E->getOperatorDelete()) {
11603 // Mark any declarations we need as referenced.
11604 // FIXME: instantiation-specific.
11605 if (OperatorDelete)
11606 SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorDelete);
11607
11608 if (!E->getArgument()->isTypeDependent()) {
11609 QualType Destroyed = SemaRef.Context.getBaseElementType(
11610 E->getDestroyedType());
11611 if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) {
11612 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl());
11613 SemaRef.MarkFunctionReferenced(E->getBeginLoc(),
11614 SemaRef.LookupDestructor(Record));
11615 }
11616 }
11617
11618 return E;
11619 }
11620
11621 return getDerived().RebuildCXXDeleteExpr(
11622 E->getBeginLoc(), E->isGlobalDelete(), E->isArrayForm(), Operand.get());
11623}
11624
11625template<typename Derived>
11626ExprResult
11627TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
11628 CXXPseudoDestructorExpr *E) {
11629 ExprResult Base = getDerived().TransformExpr(E->getBase());
11630 if (Base.isInvalid())
11631 return ExprError();
11632
11633 ParsedType ObjectTypePtr;
11634 bool MayBePseudoDestructor = false;
11635 Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(),
11636 E->getOperatorLoc(),
11637 E->isArrow()? tok::arrow : tok::period,
11638 ObjectTypePtr,
11639 MayBePseudoDestructor);
11640 if (Base.isInvalid())
11641 return ExprError();
11642
11643 QualType ObjectType = ObjectTypePtr.get();
11644 NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc();
11645 if (QualifierLoc) {
11646 QualifierLoc
11647 = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType);
11648 if (!QualifierLoc)
11649 return ExprError();
11650 }
11651 CXXScopeSpec SS;
11652 SS.Adopt(QualifierLoc);
11653
11654 PseudoDestructorTypeStorage Destroyed;
11655 if (E->getDestroyedTypeInfo()) {
11656 TypeSourceInfo *DestroyedTypeInfo
11657 = getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(),
11658 ObjectType, nullptr, SS);
11659 if (!DestroyedTypeInfo)
11660 return ExprError();
11661 Destroyed = DestroyedTypeInfo;
11662 } else if (!ObjectType.isNull() && ObjectType->isDependentType()) {
11663 // We aren't likely to be able to resolve the identifier down to a type
11664 // now anyway, so just retain the identifier.
11665 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(),
11666 E->getDestroyedTypeLoc());
11667 } else {
11668 // Look for a destructor known with the given name.
11669 ParsedType T = SemaRef.getDestructorName(E->getTildeLoc(),
11670 *E->getDestroyedTypeIdentifier(),
11671 E->getDestroyedTypeLoc(),
11672 /*Scope=*/nullptr,
11673 SS, ObjectTypePtr,
11674 false);
11675 if (!T)
11676 return ExprError();
11677
11678 Destroyed
11679 = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T),
11680 E->getDestroyedTypeLoc());
11681 }
11682
11683 TypeSourceInfo *ScopeTypeInfo = nullptr;
11684 if (E->getScopeTypeInfo()) {
11685 CXXScopeSpec EmptySS;
11686 ScopeTypeInfo = getDerived().TransformTypeInObjectScope(
11687 E->getScopeTypeInfo(), ObjectType, nullptr, EmptySS);
11688 if (!ScopeTypeInfo)
11689 return ExprError();
11690 }
11691
11692 return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(),
11693 E->getOperatorLoc(),
11694 E->isArrow(),
11695 SS,
11696 ScopeTypeInfo,
11697 E->getColonColonLoc(),
11698 E->getTildeLoc(),
11699 Destroyed);
11700}
11701
11702template <typename Derived>
11703bool TreeTransform<Derived>::TransformOverloadExprDecls(OverloadExpr *Old,
11704 bool RequiresADL,
11705 LookupResult &R) {
11706 // Transform all the decls.
11707 bool AllEmptyPacks = true;
11708 for (auto *OldD : Old->decls()) {
11709 Decl *InstD = getDerived().TransformDecl(Old->getNameLoc(), OldD);
11710 if (!InstD) {
11711 // Silently ignore these if a UsingShadowDecl instantiated to nothing.
11712 // This can happen because of dependent hiding.
11713 if (isa<UsingShadowDecl>(OldD))
11714 continue;
11715 else {
11716 R.clear();
11717 return true;
11718 }
11719 }
11720
11721 // Expand using pack declarations.
11722 NamedDecl *SingleDecl = cast<NamedDecl>(InstD);
11723 ArrayRef<NamedDecl*> Decls = SingleDecl;
11724 if (auto *UPD = dyn_cast<UsingPackDecl>(InstD))
11725 Decls = UPD->expansions();
11726
11727 // Expand using declarations.
11728 for (auto *D : Decls) {
11729 if (auto *UD = dyn_cast<UsingDecl>(D)) {
11730 for (auto *SD : UD->shadows())
11731 R.addDecl(SD);
11732 } else {
11733 R.addDecl(D);
11734 }
11735 }
11736
11737 AllEmptyPacks &= Decls.empty();
11738 };
11739
11740 // C++ [temp.res]/8.4.2:
11741 // The program is ill-formed, no diagnostic required, if [...] lookup for
11742 // a name in the template definition found a using-declaration, but the
11743 // lookup in the corresponding scope in the instantiation odoes not find
11744 // any declarations because the using-declaration was a pack expansion and
11745 // the corresponding pack is empty
11746 if (AllEmptyPacks && !RequiresADL) {
11747 getSema().Diag(Old->getNameLoc(), diag::err_using_pack_expansion_empty)
11748 << isa<UnresolvedMemberExpr>(Old) << Old->getName();
11749 return true;
11750 }
11751
11752 // Resolve a kind, but don't do any further analysis. If it's
11753 // ambiguous, the callee needs to deal with it.
11754 R.resolveKind();
11755 return false;
11756}
11757
11758template<typename Derived>
11759ExprResult
11760TreeTransform<Derived>::TransformUnresolvedLookupExpr(
11761 UnresolvedLookupExpr *Old) {
11762 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(),
11763 Sema::LookupOrdinaryName);
11764
11765 // Transform the declaration set.
11766 if (TransformOverloadExprDecls(Old, Old->requiresADL(), R))
11767 return ExprError();
11768
11769 // Rebuild the nested-name qualifier, if present.
11770 CXXScopeSpec SS;
11771 if (Old->getQualifierLoc()) {
11772 NestedNameSpecifierLoc QualifierLoc
11773 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
11774 if (!QualifierLoc)
11775 return ExprError();
11776
11777 SS.Adopt(QualifierLoc);
11778 }
11779
11780 if (Old->getNamingClass()) {
11781 CXXRecordDecl *NamingClass
11782 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
11783 Old->getNameLoc(),
11784 Old->getNamingClass()));
11785 if (!NamingClass) {
11786 R.clear();
11787 return ExprError();
11788 }
11789
11790 R.setNamingClass(NamingClass);
11791 }
11792
11793 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
11794
11795 // If we have neither explicit template arguments, nor the template keyword,
11796 // it's a normal declaration name or member reference.
11797 if (!Old->hasExplicitTemplateArgs() && !TemplateKWLoc.isValid()) {
11798 NamedDecl *D = R.getAsSingle<NamedDecl>();
11799 // In a C++11 unevaluated context, an UnresolvedLookupExpr might refer to an
11800 // instance member. In other contexts, BuildPossibleImplicitMemberExpr will
11801 // give a good diagnostic.
11802 if (D && D->isCXXInstanceMember()) {
11803 return SemaRef.BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, R,
11804 /*TemplateArgs=*/nullptr,
11805 /*Scope=*/nullptr);
11806 }
11807
11808 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL());
11809 }
11810
11811 // If we have template arguments, rebuild them, then rebuild the
11812 // templateid expression.
11813 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc());
11814 if (Old->hasExplicitTemplateArgs() &&
11815 getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
11816 Old->getNumTemplateArgs(),
11817 TransArgs)) {
11818 R.clear();
11819 return ExprError();
11820 }
11821
11822 return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R,
11823 Old->requiresADL(), &TransArgs);
11824}
11825
11826template<typename Derived>
11827ExprResult
11828TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) {
11829 bool ArgChanged = false;
11830 SmallVector<TypeSourceInfo *, 4> Args;
11831 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
11832 TypeSourceInfo *From = E->getArg(I);
11833 TypeLoc FromTL = From->getTypeLoc();
11834 if (!FromTL.getAs<PackExpansionTypeLoc>()) {
11835 TypeLocBuilder TLB;
11836 TLB.reserve(FromTL.getFullDataSize());
11837 QualType To = getDerived().TransformType(TLB, FromTL);
11838 if (To.isNull())
11839 return ExprError();
11840
11841 if (To == From->getType())
11842 Args.push_back(From);
11843 else {
11844 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
11845 ArgChanged = true;
11846 }
11847 continue;
11848 }
11849
11850 ArgChanged = true;
11851
11852 // We have a pack expansion. Instantiate it.
11853 PackExpansionTypeLoc ExpansionTL = FromTL.castAs<PackExpansionTypeLoc>();
11854 TypeLoc PatternTL = ExpansionTL.getPatternLoc();
11855 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
11856 SemaRef.collectUnexpandedParameterPacks(PatternTL, Unexpanded);
11857
11858 // Determine whether the set of unexpanded parameter packs can and should
11859 // be expanded.
11860 bool Expand = true;
11861 bool RetainExpansion = false;
11862 Optional<unsigned> OrigNumExpansions =
11863 ExpansionTL.getTypePtr()->getNumExpansions();
11864 Optional<unsigned> NumExpansions = OrigNumExpansions;
11865 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
11866 PatternTL.getSourceRange(),
11867 Unexpanded,
11868 Expand, RetainExpansion,
11869 NumExpansions))
11870 return ExprError();
11871
11872 if (!Expand) {
11873 // The transform has determined that we should perform a simple
11874 // transformation on the pack expansion, producing another pack
11875 // expansion.
11876 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
11877
11878 TypeLocBuilder TLB;
11879 TLB.reserve(From->getTypeLoc().getFullDataSize());
11880
11881 QualType To = getDerived().TransformType(TLB, PatternTL);
11882 if (To.isNull())
11883 return ExprError();
11884
11885 To = getDerived().RebuildPackExpansionType(To,
11886 PatternTL.getSourceRange(),
11887 ExpansionTL.getEllipsisLoc(),
11888 NumExpansions);
11889 if (To.isNull())
11890 return ExprError();
11891
11892 PackExpansionTypeLoc ToExpansionTL
11893 = TLB.push<PackExpansionTypeLoc>(To);
11894 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
11895 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
11896 continue;
11897 }
11898
11899 // Expand the pack expansion by substituting for each argument in the
11900 // pack(s).
11901 for (unsigned I = 0; I != *NumExpansions; ++I) {
11902 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
11903 TypeLocBuilder TLB;
11904 TLB.reserve(PatternTL.getFullDataSize());
11905 QualType To = getDerived().TransformType(TLB, PatternTL);
11906 if (To.isNull())
11907 return ExprError();
11908
11909 if (To->containsUnexpandedParameterPack()) {
11910 To = getDerived().RebuildPackExpansionType(To,
11911 PatternTL.getSourceRange(),
11912 ExpansionTL.getEllipsisLoc(),
11913 NumExpansions);
11914 if (To.isNull())
11915 return ExprError();
11916
11917 PackExpansionTypeLoc ToExpansionTL
11918 = TLB.push<PackExpansionTypeLoc>(To);
11919 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
11920 }
11921
11922 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
11923 }
11924
11925 if (!RetainExpansion)
11926 continue;
11927
11928 // If we're supposed to retain a pack expansion, do so by temporarily
11929 // forgetting the partially-substituted parameter pack.
11930 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
11931
11932 TypeLocBuilder TLB;
11933 TLB.reserve(From->getTypeLoc().getFullDataSize());
11934
11935 QualType To = getDerived().TransformType(TLB, PatternTL);
11936 if (To.isNull())
11937 return ExprError();
11938
11939 To = getDerived().RebuildPackExpansionType(To,
11940 PatternTL.getSourceRange(),
11941 ExpansionTL.getEllipsisLoc(),
11942 NumExpansions);
11943 if (To.isNull())
11944 return ExprError();
11945
11946 PackExpansionTypeLoc ToExpansionTL
11947 = TLB.push<PackExpansionTypeLoc>(To);
11948 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
11949 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
11950 }
11951
11952 if (!getDerived().AlwaysRebuild() && !ArgChanged)
11953 return E;
11954
11955 return getDerived().RebuildTypeTrait(E->getTrait(), E->getBeginLoc(), Args,
11956 E->getEndLoc());
11957}
11958
11959template<typename Derived>
11960ExprResult
11961TreeTransform<Derived>::TransformConceptSpecializationExpr(
11962 ConceptSpecializationExpr *E) {
11963 const ASTTemplateArgumentListInfo *Old = E->getTemplateArgsAsWritten();
11964 TemplateArgumentListInfo TransArgs(Old->LAngleLoc, Old->RAngleLoc);
11965 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
11966 Old->NumTemplateArgs, TransArgs))
11967 return ExprError();
11968
11969 return getDerived().RebuildConceptSpecializationExpr(
11970 E->getNestedNameSpecifierLoc(), E->getTemplateKWLoc(),
11971 E->getConceptNameInfo(), E->getFoundDecl(), E->getNamedConcept(),
11972 &TransArgs);
11973}
11974
11975template<typename Derived>
11976ExprResult
11977TreeTransform<Derived>::TransformRequiresExpr(RequiresExpr *E) {
11978 SmallVector<ParmVarDecl*, 4> TransParams;
11979 SmallVector<QualType, 4> TransParamTypes;
11980 Sema::ExtParameterInfoBuilder ExtParamInfos;
11981
11982 // C++2a [expr.prim.req]p2
11983 // Expressions appearing within a requirement-body are unevaluated operands.
11984 EnterExpressionEvaluationContext Ctx(
11985 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
11986
11987 RequiresExprBodyDecl *Body = RequiresExprBodyDecl::Create(
11988 getSema().Context, getSema().CurContext,
11989 E->getBody()->getBeginLoc());
11990
11991 Sema::ContextRAII SavedContext(getSema(), Body, /*NewThisContext*/false);
11992
11993 if (getDerived().TransformFunctionTypeParams(E->getRequiresKWLoc(),
11994 E->getLocalParameters(),
11995 /*ParamTypes=*/nullptr,
11996 /*ParamInfos=*/nullptr,
11997 TransParamTypes, &TransParams,
11998 ExtParamInfos))
11999 return ExprError();
12000
12001 for (ParmVarDecl *Param : TransParams)
12002 Param->setDeclContext(Body);
12003
12004 SmallVector<concepts::Requirement *, 4> TransReqs;
12005 if (getDerived().TransformRequiresExprRequirements(E->getRequirements(),
12006 TransReqs))
12007 return ExprError();
12008
12009 for (concepts::Requirement *Req : TransReqs) {
12010 if (auto *ER = dyn_cast<concepts::ExprRequirement>(Req)) {
12011 if (ER->getReturnTypeRequirement().isTypeConstraint()) {
12012 ER->getReturnTypeRequirement()
12013 .getTypeConstraintTemplateParameterList()->getParam(0)
12014 ->setDeclContext(Body);
12015 }
12016 }
12017 }
12018
12019 return getDerived().RebuildRequiresExpr(E->getRequiresKWLoc(), Body,
12020 TransParams, TransReqs,
12021 E->getRBraceLoc());
12022}
12023
12024template<typename Derived>
12025bool TreeTransform<Derived>::TransformRequiresExprRequirements(
12026 ArrayRef<concepts::Requirement *> Reqs,
12027 SmallVectorImpl<concepts::Requirement *> &Transformed) {
12028 for (concepts::Requirement *Req : Reqs) {
12029 concepts::Requirement *TransReq = nullptr;
12030 if (auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req))
12031 TransReq = getDerived().TransformTypeRequirement(TypeReq);
12032 else if (auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Req))
12033 TransReq = getDerived().TransformExprRequirement(ExprReq);
12034 else
12035 TransReq = getDerived().TransformNestedRequirement(
12036 cast<concepts::NestedRequirement>(Req));
12037 if (!TransReq)
12038 return true;
12039 Transformed.push_back(TransReq);
12040 }
12041 return false;
12042}
12043
12044template<typename Derived>
12045concepts::TypeRequirement *
12046TreeTransform<Derived>::TransformTypeRequirement(
12047 concepts::TypeRequirement *Req) {
12048 if (Req->isSubstitutionFailure()) {
12049 if (getDerived().AlwaysRebuild())
12050 return getDerived().RebuildTypeRequirement(
12051 Req->getSubstitutionDiagnostic());
12052 return Req;
12053 }
12054 TypeSourceInfo *TransType = getDerived().TransformType(Req->getType());
12055 if (!TransType)
12056 return nullptr;
12057 return getDerived().RebuildTypeRequirement(TransType);
12058}
12059
12060template<typename Derived>
12061concepts::ExprRequirement *
12062TreeTransform<Derived>::TransformExprRequirement(concepts::ExprRequirement *Req) {
12063 llvm::PointerUnion<Expr *, concepts::Requirement::SubstitutionDiagnostic *> TransExpr;
12064 if (Req->isExprSubstitutionFailure())
12065 TransExpr = Req->getExprSubstitutionDiagnostic();
12066 else {
12067 ExprResult TransExprRes = getDerived().TransformExpr(Req->getExpr());
12068 if (TransExprRes.isInvalid())
12069 return nullptr;
12070 TransExpr = TransExprRes.get();
12071 }
12072
12073 llvm::Optional<concepts::ExprRequirement::ReturnTypeRequirement> TransRetReq;
12074 const auto &RetReq = Req->getReturnTypeRequirement();
12075 if (RetReq.isEmpty())
12076 TransRetReq.emplace();
12077 else if (RetReq.isSubstitutionFailure())
12078 TransRetReq.emplace(RetReq.getSubstitutionDiagnostic());
12079 else if (RetReq.isTypeConstraint()) {
12080 TemplateParameterList *OrigTPL =
12081 RetReq.getTypeConstraintTemplateParameterList();
12082 TemplateParameterList *TPL =
12083 getDerived().TransformTemplateParameterList(OrigTPL);
12084 if (!TPL)
12085 return nullptr;
12086 TransRetReq.emplace(TPL);
12087 }
12088 assert(TransRetReq.hasValue() &&
12089 "All code paths leading here must set TransRetReq");
12090 if (Expr *E = TransExpr.dyn_cast<Expr *>())
12091 return getDerived().RebuildExprRequirement(E, Req->isSimple(),
12092 Req->getNoexceptLoc(),
12093 std::move(*TransRetReq));
12094 return getDerived().RebuildExprRequirement(
12095 TransExpr.get<concepts::Requirement::SubstitutionDiagnostic *>(),
12096 Req->isSimple(), Req->getNoexceptLoc(), std::move(*TransRetReq));
12097}
12098
12099template<typename Derived>
12100concepts::NestedRequirement *
12101TreeTransform<Derived>::TransformNestedRequirement(
12102 concepts::NestedRequirement *Req) {
12103 if (Req->isSubstitutionFailure()) {
12104 if (getDerived().AlwaysRebuild())
12105 return getDerived().RebuildNestedRequirement(
12106 Req->getSubstitutionDiagnostic());
12107 return Req;
12108 }
12109 ExprResult TransConstraint =
12110 getDerived().TransformExpr(Req->getConstraintExpr());
12111 if (TransConstraint.isInvalid())
12112 return nullptr;
12113 return getDerived().RebuildNestedRequirement(TransConstraint.get());
12114}
12115
12116template<typename Derived>
12117ExprResult
12118TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
12119 TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo());
12120 if (!T)
12121 return ExprError();
12122
12123 if (!getDerived().AlwaysRebuild() &&
12124 T == E->getQueriedTypeSourceInfo())
12125 return E;
12126
12127 ExprResult SubExpr;
12128 {
12129 EnterExpressionEvaluationContext Unevaluated(
12130 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
12131 SubExpr = getDerived().TransformExpr(E->getDimensionExpression());
12132 if (SubExpr.isInvalid())
12133 return ExprError();
12134
12135 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getDimensionExpression())
12136 return E;
12137 }
12138
12139 return getDerived().RebuildArrayTypeTrait(E->getTrait(), E->getBeginLoc(), T,
12140 SubExpr.get(), E->getEndLoc());
12141}
12142
12143template<typename Derived>
12144ExprResult
12145TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *E) {
12146 ExprResult SubExpr;
12147 {
12148 EnterExpressionEvaluationContext Unevaluated(
12149 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
12150 SubExpr = getDerived().TransformExpr(E->getQueriedExpression());
12151 if (SubExpr.isInvalid())
12152 return ExprError();
12153
12154 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getQueriedExpression())
12155 return E;
12156 }
12157
12158 return getDerived().RebuildExpressionTrait(E->getTrait(), E->getBeginLoc(),
12159 SubExpr.get(), E->getEndLoc());
12160}
12161
12162template <typename Derived>
12163ExprResult TreeTransform<Derived>::TransformParenDependentScopeDeclRefExpr(
12164 ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool AddrTaken,
12165 TypeSourceInfo **RecoveryTSI) {
12166 ExprResult NewDRE = getDerived().TransformDependentScopeDeclRefExpr(
12167 DRE, AddrTaken, RecoveryTSI);
12168
12169 // Propagate both errors and recovered types, which return ExprEmpty.
12170 if (!NewDRE.isUsable())
12171 return NewDRE;
12172
12173 // We got an expr, wrap it up in parens.
12174 if (!getDerived().AlwaysRebuild() && NewDRE.get() == DRE)
12175 return PE;
12176 return getDerived().RebuildParenExpr(NewDRE.get(), PE->getLParen(),
12177 PE->getRParen());
12178}
12179
12180template <typename Derived>
12181ExprResult TreeTransform<Derived>::TransformDependentScopeDeclRefExpr(
12182 DependentScopeDeclRefExpr *E) {
12183 return TransformDependentScopeDeclRefExpr(E, /*IsAddressOfOperand=*/false,
12184 nullptr);
12185}
12186
12187template<typename Derived>
12188ExprResult
12189TreeTransform<Derived>::TransformDependentScopeDeclRefExpr(
12190 DependentScopeDeclRefExpr *E,
12191 bool IsAddressOfOperand,
12192 TypeSourceInfo **RecoveryTSI) {
12193 assert(E->getQualifierLoc());
12194 NestedNameSpecifierLoc QualifierLoc
12195 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
12196 if (!QualifierLoc)
12197 return ExprError();
12198 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
12199
12200 // TODO: If this is a conversion-function-id, verify that the
12201 // destination type name (if present) resolves the same way after
12202 // instantiation as it did in the local scope.
12203
12204 DeclarationNameInfo NameInfo
12205 = getDerived().TransformDeclarationNameInfo(E->getNameInfo());
12206 if (!NameInfo.getName())
12207 return ExprError();
12208
12209 if (!E->hasExplicitTemplateArgs()) {
12210 if (!getDerived().AlwaysRebuild() &&
12211 QualifierLoc == E->getQualifierLoc() &&
12212 // Note: it is sufficient to compare the Name component of NameInfo:
12213 // if name has not changed, DNLoc has not changed either.
12214 NameInfo.getName() == E->getDeclName())
12215 return E;
12216
12217 return getDerived().RebuildDependentScopeDeclRefExpr(
12218 QualifierLoc, TemplateKWLoc, NameInfo, /*TemplateArgs=*/nullptr,
12219 IsAddressOfOperand, RecoveryTSI);
12220 }
12221
12222 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
12223 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
12224 E->getNumTemplateArgs(),
12225 TransArgs))
12226 return ExprError();
12227
12228 return getDerived().RebuildDependentScopeDeclRefExpr(
12229 QualifierLoc, TemplateKWLoc, NameInfo, &TransArgs, IsAddressOfOperand,
12230 RecoveryTSI);
12231}
12232
12233template<typename Derived>
12234ExprResult
12235TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) {
12236 // CXXConstructExprs other than for list-initialization and
12237 // CXXTemporaryObjectExpr are always implicit, so when we have
12238 // a 1-argument construction we just transform that argument.
12239 if (getDerived().AllowSkippingCXXConstructExpr() &&
12240 ((E->getNumArgs() == 1 ||
12241 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) &&
12242 (!getDerived().DropCallArgument(E->getArg(0))) &&
12243 !E->isListInitialization()))
12244 return getDerived().TransformExpr(E->getArg(0));
12245
12246 TemporaryBase Rebase(*this, /*FIXME*/ E->getBeginLoc(), DeclarationName());
12247
12248 QualType T = getDerived().TransformType(E->getType());
12249 if (T.isNull())
12250 return ExprError();
12251
12252 CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
12253 getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
12254 if (!Constructor)
12255 return ExprError();
12256
12257 bool ArgumentChanged = false;
12258 SmallVector<Expr*, 8> Args;
12259 {
12260 EnterExpressionEvaluationContext Context(
12261 getSema(), EnterExpressionEvaluationContext::InitList,
12262 E->isListInitialization());
12263 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
12264 &ArgumentChanged))
12265 return ExprError();
12266 }
12267
12268 if (!getDerived().AlwaysRebuild() &&
12269 T == E->getType() &&
12270 Constructor == E->getConstructor() &&
12271 !ArgumentChanged) {
12272 // Mark the constructor as referenced.
12273 // FIXME: Instantiation-specific
12274 SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor);
12275 return E;
12276 }
12277
12278 return getDerived().RebuildCXXConstructExpr(
12279 T, /*FIXME:*/ E->getBeginLoc(), Constructor, E->isElidable(), Args,
12280 E->hadMultipleCandidates(), E->isListInitialization(),
12281 E->isStdInitListInitialization(), E->requiresZeroInitialization(),
12282 E->getConstructionKind(), E->getParenOrBraceRange());
12283}
12284
12285template<typename Derived>
12286ExprResult TreeTransform<Derived>::TransformCXXInheritedCtorInitExpr(
12287 CXXInheritedCtorInitExpr *E) {
12288 QualType T = getDerived().TransformType(E->getType());
12289 if (T.isNull())
12290 return ExprError();
12291
12292 CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
12293 getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
12294 if (!Constructor)
12295 return ExprError();
12296
12297 if (!getDerived().AlwaysRebuild() &&
12298 T == E->getType() &&
12299 Constructor == E->getConstructor()) {
12300 // Mark the constructor as referenced.
12301 // FIXME: Instantiation-specific
12302 SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor);
12303 return E;
12304 }
12305
12306 return getDerived().RebuildCXXInheritedCtorInitExpr(
12307 T, E->getLocation(), Constructor,
12308 E->constructsVBase(), E->inheritedFromVBase());
12309}
12310
12311/// Transform a C++ temporary-binding expression.
12312///
12313/// Since CXXBindTemporaryExpr nodes are implicitly generated, we just
12314/// transform the subexpression and return that.
12315template<typename Derived>
12316ExprResult
12317TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
12318 return getDerived().TransformExpr(E->getSubExpr());
12319}
12320
12321/// Transform a C++ expression that contains cleanups that should
12322/// be run after the expression is evaluated.
12323///
12324/// Since ExprWithCleanups nodes are implicitly generated, we
12325/// just transform the subexpression and return that.
12326template<typename Derived>
12327ExprResult
12328TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) {
12329 return getDerived().TransformExpr(E->getSubExpr());
12330}
12331
12332template<typename Derived>
12333ExprResult
12334TreeTransform<Derived>::TransformCXXTemporaryObjectExpr(
12335 CXXTemporaryObjectExpr *E) {
12336 TypeSourceInfo *T =
12337 getDerived().TransformTypeWithDeducedTST(E->getTypeSourceInfo());
12338 if (!T)
12339 return ExprError();
12340
12341 CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
12342 getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
12343 if (!Constructor)
12344 return ExprError();
12345
12346 bool ArgumentChanged = false;
12347 SmallVector<Expr*, 8> Args;
12348 Args.reserve(E->getNumArgs());
12349 {
12350 EnterExpressionEvaluationContext Context(
12351 getSema(), EnterExpressionEvaluationContext::InitList,
12352 E->isListInitialization());
12353 if (TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
12354 &ArgumentChanged))
12355 return ExprError();
12356 }
12357
12358 if (!getDerived().AlwaysRebuild() &&
12359 T == E->getTypeSourceInfo() &&
12360 Constructor == E->getConstructor() &&
12361 !ArgumentChanged) {
12362 // FIXME: Instantiation-specific
12363 SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor);
12364 return SemaRef.MaybeBindToTemporary(E);
12365 }
12366
12367 // FIXME: We should just pass E->isListInitialization(), but we're not
12368 // prepared to handle list-initialization without a child InitListExpr.
12369 SourceLocation LParenLoc = T->getTypeLoc().getEndLoc();
12370 return getDerived().RebuildCXXTemporaryObjectExpr(
12371 T, LParenLoc, Args, E->getEndLoc(),
12372 /*ListInitialization=*/LParenLoc.isInvalid());
12373}
12374
12375template<typename Derived>
12376ExprResult
12377TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
12378 // Transform any init-capture expressions before entering the scope of the
12379 // lambda body, because they are not semantically within that scope.
12380 typedef std::pair<ExprResult, QualType> InitCaptureInfoTy;
12381 struct TransformedInitCapture {
12382 // The location of the ... if the result is retaining a pack expansion.
12383 SourceLocation EllipsisLoc;
12384 // Zero or more expansions of the init-capture.
12385 SmallVector<InitCaptureInfoTy, 4> Expansions;
12386 };
12387 SmallVector<TransformedInitCapture, 4> InitCaptures;
12388 InitCaptures.resize(E->explicit_capture_end() - E->explicit_capture_begin());
12389 for (LambdaExpr::capture_iterator C = E->capture_begin(),
12390 CEnd = E->capture_end();
12391 C != CEnd; ++C) {
12392 if (!E->isInitCapture(C))
12393 continue;
12394
12395 TransformedInitCapture &Result = InitCaptures[C - E->capture_begin()];
12396 VarDecl *OldVD = C->getCapturedVar();
12397
12398 auto SubstInitCapture = [&](SourceLocation EllipsisLoc,
12399 Optional<unsigned> NumExpansions) {
12400 ExprResult NewExprInitResult = getDerived().TransformInitializer(
12401 OldVD->getInit(), OldVD->getInitStyle() == VarDecl::CallInit);
12402
12403 if (NewExprInitResult.isInvalid()) {
12404 Result.Expansions.push_back(InitCaptureInfoTy(ExprError(), QualType()));
12405 return;
12406 }
12407 Expr *NewExprInit = NewExprInitResult.get();
12408
12409 QualType NewInitCaptureType =
12410 getSema().buildLambdaInitCaptureInitialization(
12411 C->getLocation(), OldVD->getType()->isReferenceType(),
12412 EllipsisLoc, NumExpansions, OldVD->getIdentifier(),
12413 C->getCapturedVar()->getInitStyle() != VarDecl::CInit,
12414 NewExprInit);
12415 Result.Expansions.push_back(
12416 InitCaptureInfoTy(NewExprInit, NewInitCaptureType));
12417 };
12418
12419 // If this is an init-capture pack, consider expanding the pack now.
12420 if (OldVD->isParameterPack()) {
12421 PackExpansionTypeLoc ExpansionTL = OldVD->getTypeSourceInfo()
12422 ->getTypeLoc()
12423 .castAs<PackExpansionTypeLoc>();
12424 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
12425 SemaRef.collectUnexpandedParameterPacks(OldVD->getInit(), Unexpanded);
12426
12427 // Determine whether the set of unexpanded parameter packs can and should
12428 // be expanded.
12429 bool Expand = true;
12430 bool RetainExpansion = false;
12431 Optional<unsigned> OrigNumExpansions =
12432 ExpansionTL.getTypePtr()->getNumExpansions();
12433 Optional<unsigned> NumExpansions = OrigNumExpansions;
12434 if (getDerived().TryExpandParameterPacks(
12435 ExpansionTL.getEllipsisLoc(),
12436 OldVD->getInit()->getSourceRange(), Unexpanded, Expand,
12437 RetainExpansion, NumExpansions))
12438 return ExprError();
12439 if (Expand) {
12440 for (unsigned I = 0; I != *NumExpansions; ++I) {
12441 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
12442 SubstInitCapture(SourceLocation(), None);
12443 }
12444 }
12445 if (!Expand || RetainExpansion) {
12446 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
12447 SubstInitCapture(ExpansionTL.getEllipsisLoc(), NumExpansions);
12448 Result.EllipsisLoc = ExpansionTL.getEllipsisLoc();
12449 }
12450 } else {
12451 SubstInitCapture(SourceLocation(), None);
12452 }
12453 }
12454
12455 LambdaScopeInfo *LSI = getSema().PushLambdaScope();
12456 Sema::FunctionScopeRAII FuncScopeCleanup(getSema());
12457
12458 // Transform the template parameters, and add them to the current
12459 // instantiation scope. The null case is handled correctly.
12460 auto TPL = getDerived().TransformTemplateParameterList(
12461 E->getTemplateParameterList());
12462 LSI->GLTemplateParameterList = TPL;
12463
12464 // Transform the type of the original lambda's call operator.
12465 // The transformation MUST be done in the CurrentInstantiationScope since
12466 // it introduces a mapping of the original to the newly created
12467 // transformed parameters.
12468 TypeSourceInfo *NewCallOpTSI = nullptr;
12469 {
12470 TypeSourceInfo *OldCallOpTSI = E->getCallOperator()->getTypeSourceInfo();
12471 FunctionProtoTypeLoc OldCallOpFPTL =
12472 OldCallOpTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>();
12473
12474 TypeLocBuilder NewCallOpTLBuilder;
12475 SmallVector<QualType, 4> ExceptionStorage;
12476 TreeTransform *This = this; // Work around gcc.gnu.org/PR56135.
12477 QualType NewCallOpType = TransformFunctionProtoType(
12478 NewCallOpTLBuilder, OldCallOpFPTL, nullptr, Qualifiers(),
12479 [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) {
12480 return This->TransformExceptionSpec(OldCallOpFPTL.getBeginLoc(), ESI,
12481 ExceptionStorage, Changed);
12482 });
12483 if (NewCallOpType.isNull())
12484 return ExprError();
12485 NewCallOpTSI = NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context,
12486 NewCallOpType);
12487 }
12488
12489 // Transform the trailing requires clause
12490 ExprResult NewTrailingRequiresClause;
12491 if (Expr *TRC = E->getCallOperator()->getTrailingRequiresClause())
12492 // FIXME: Concepts: Substitution into requires clause should only happen
12493 // when checking satisfaction.
12494 NewTrailingRequiresClause = getDerived().TransformExpr(TRC);
12495
12496 // Create the local class that will describe the lambda.
12497 // FIXME: KnownDependent below is wrong when substituting inside a templated
12498 // context that isn't a DeclContext (such as a variable template).
12499 CXXRecordDecl *OldClass = E->getLambdaClass();
12500 CXXRecordDecl *Class
12501 = getSema().createLambdaClosureType(E->getIntroducerRange(),
12502 NewCallOpTSI,
12503 /*KnownDependent=*/false,
12504 E->getCaptureDefault());
12505 getDerived().transformedLocalDecl(OldClass, {Class});
12506
12507 Optional<std::tuple<bool, unsigned, unsigned, Decl *>> Mangling;
12508 if (getDerived().ReplacingOriginal())
12509 Mangling = std::make_tuple(OldClass->hasKnownLambdaInternalLinkage(),
12510 OldClass->getLambdaManglingNumber(),
12511 OldClass->getDeviceLambdaManglingNumber(),
12512 OldClass->getLambdaContextDecl());
12513
12514 // Build the call operator.
12515 CXXMethodDecl *NewCallOperator = getSema().startLambdaDefinition(
12516 Class, E->getIntroducerRange(), NewCallOpTSI,
12517 E->getCallOperator()->getEndLoc(),
12518 NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams(),
12519 E->getCallOperator()->getConstexprKind(),
12520 NewTrailingRequiresClause.get());
12521
12522 LSI->CallOperator = NewCallOperator;
12523
12524 getDerived().transformAttrs(E->getCallOperator(), NewCallOperator);
12525 getDerived().transformedLocalDecl(E->getCallOperator(), {NewCallOperator});
12526
12527 // Number the lambda for linkage purposes if necessary.
12528 getSema().handleLambdaNumbering(Class, NewCallOperator, Mangling);
12529
12530 // Introduce the context of the call operator.
12531 Sema::ContextRAII SavedContext(getSema(), NewCallOperator,
12532 /*NewThisContext*/false);
12533
12534 // Enter the scope of the lambda.
12535 getSema().buildLambdaScope(LSI, NewCallOperator,
12536 E->getIntroducerRange(),
12537 E->getCaptureDefault(),
12538 E->getCaptureDefaultLoc(),
12539 E->hasExplicitParameters(),
12540 E->hasExplicitResultType(),
12541 E->isMutable());
12542
12543 bool Invalid = false;
12544
12545 // Transform captures.
12546 for (LambdaExpr::capture_iterator C = E->capture_begin(),
12547 CEnd = E->capture_end();
12548 C != CEnd; ++C) {
12549 // When we hit the first implicit capture, tell Sema that we've finished
12550 // the list of explicit captures.
12551 if (C->isImplicit())
12552 break;
12553
12554 // Capturing 'this' is trivial.
12555 if (C->capturesThis()) {
12556 getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(),
12557 /*BuildAndDiagnose*/ true, nullptr,
12558 C->getCaptureKind() == LCK_StarThis);
12559 continue;
12560 }
12561 // Captured expression will be recaptured during captured variables
12562 // rebuilding.
12563 if (C->capturesVLAType())
12564 continue;
12565
12566 // Rebuild init-captures, including the implied field declaration.
12567 if (E->isInitCapture(C)) {
12568 TransformedInitCapture &NewC = InitCaptures[C - E->capture_begin()];
12569
12570 VarDecl *OldVD = C->getCapturedVar();
12571 llvm::SmallVector<Decl*, 4> NewVDs;
12572
12573 for (InitCaptureInfoTy &Info : NewC.Expansions) {
12574 ExprResult Init = Info.first;
12575 QualType InitQualType = Info.second;
12576 if (Init.isInvalid() || InitQualType.isNull()) {
12577 Invalid = true;
12578 break;
12579 }
12580 VarDecl *NewVD = getSema().createLambdaInitCaptureVarDecl(
12581 OldVD->getLocation(), InitQualType, NewC.EllipsisLoc,
12582 OldVD->getIdentifier(), OldVD->getInitStyle(), Init.get());
12583 if (!NewVD) {
12584 Invalid = true;
12585 break;
12586 }
12587 NewVDs.push_back(NewVD);
12588 getSema().addInitCapture(LSI, NewVD);
12589 }
12590
12591 if (Invalid)
12592 break;
12593
12594 getDerived().transformedLocalDecl(OldVD, NewVDs);
12595 continue;
12596 }
12597
12598 assert(C->capturesVariable() && "unexpected kind of lambda capture");
12599
12600 // Determine the capture kind for Sema.
12601 Sema::TryCaptureKind Kind
12602 = C->isImplicit()? Sema::TryCapture_Implicit
12603 : C->getCaptureKind() == LCK_ByCopy
12604 ? Sema::TryCapture_ExplicitByVal
12605 : Sema::TryCapture_ExplicitByRef;
12606 SourceLocation EllipsisLoc;
12607 if (C->isPackExpansion()) {
12608 UnexpandedParameterPack Unexpanded(C->getCapturedVar(), C->getLocation());
12609 bool ShouldExpand = false;
12610 bool RetainExpansion = false;
12611 Optional<unsigned> NumExpansions;
12612 if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(),
12613 C->getLocation(),
12614 Unexpanded,
12615 ShouldExpand, RetainExpansion,
12616 NumExpansions)) {
12617 Invalid = true;
12618 continue;
12619 }
12620
12621 if (ShouldExpand) {
12622 // The transform has determined that we should perform an expansion;
12623 // transform and capture each of the arguments.
12624 // expansion of the pattern. Do so.
12625 VarDecl *Pack = C->getCapturedVar();
12626 for (unsigned I = 0; I != *NumExpansions; ++I) {
12627 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
12628 VarDecl *CapturedVar
12629 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
12630 Pack));
12631 if (!CapturedVar) {
12632 Invalid = true;
12633 continue;
12634 }
12635
12636 // Capture the transformed variable.
12637 getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind);
12638 }
12639
12640 // FIXME: Retain a pack expansion if RetainExpansion is true.
12641
12642 continue;
12643 }
12644
12645 EllipsisLoc = C->getEllipsisLoc();
12646 }
12647
12648 // Transform the captured variable.
12649 VarDecl *CapturedVar
12650 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
12651 C->getCapturedVar()));
12652 if (!CapturedVar || CapturedVar->isInvalidDecl()) {
12653 Invalid = true;
12654 continue;
12655 }
12656
12657 // Capture the transformed variable.
12658 getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind,
12659 EllipsisLoc);
12660 }
12661 getSema().finishLambdaExplicitCaptures(LSI);
12662
12663 // FIXME: Sema's lambda-building mechanism expects us to push an expression
12664 // evaluation context even if we're not transforming the function body.
12665 getSema().PushExpressionEvaluationContext(
12666 Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
12667
12668 // Instantiate the body of the lambda expression.
12669 StmtResult Body =
12670 Invalid ? StmtError() : getDerived().TransformLambdaBody(E, E->getBody());
12671
12672 // ActOnLambda* will pop the function scope for us.
12673 FuncScopeCleanup.disable();
12674
12675 if (Body.isInvalid()) {
12676 SavedContext.pop();
12677 getSema().ActOnLambdaError(E->getBeginLoc(), /*CurScope=*/nullptr,
12678 /*IsInstantiation=*/true);
12679 return ExprError();
12680 }
12681
12682 // Copy the LSI before ActOnFinishFunctionBody removes it.
12683 // FIXME: This is dumb. Store the lambda information somewhere that outlives
12684 // the call operator.
12685 auto LSICopy = *LSI;
12686 getSema().ActOnFinishFunctionBody(NewCallOperator, Body.get(),
12687 /*IsInstantiation*/ true);
12688 SavedContext.pop();
12689
12690 return getSema().BuildLambdaExpr(E->getBeginLoc(), Body.get()->getEndLoc(),
12691 &LSICopy);
12692}
12693
12694template<typename Derived>
12695StmtResult
12696TreeTransform<Derived>::TransformLambdaBody(LambdaExpr *E, Stmt *S) {
12697 return TransformStmt(S);
12698}
12699
12700template<typename Derived>
12701StmtResult
12702TreeTransform<Derived>::SkipLambdaBody(LambdaExpr *E, Stmt *S) {
12703 // Transform captures.
12704 for (LambdaExpr::capture_iterator C = E->capture_begin(),
12705 CEnd = E->capture_end();
12706 C != CEnd; ++C) {
12707 // When we hit the first implicit capture, tell Sema that we've finished
12708 // the list of explicit captures.
12709 if (!C->isImplicit())
12710 continue;
12711
12712 // Capturing 'this' is trivial.
12713 if (C->capturesThis()) {
12714 getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(),
12715 /*BuildAndDiagnose*/ true, nullptr,
12716 C->getCaptureKind() == LCK_StarThis);
12717 continue;
12718 }
12719 // Captured expression will be recaptured during captured variables
12720 // rebuilding.
12721 if (C->capturesVLAType())
12722 continue;
12723
12724 assert(C->capturesVariable() && "unexpected kind of lambda capture");
12725 assert(!E->isInitCapture(C) && "implicit init-capture?");
12726
12727 // Transform the captured variable.
12728 VarDecl *CapturedVar = cast_or_null<VarDecl>(
12729 getDerived().TransformDecl(C->getLocation(), C->getCapturedVar()));
12730 if (!CapturedVar || CapturedVar->isInvalidDecl())
12731 return StmtError();
12732
12733 // Capture the transformed variable.
12734 getSema().tryCaptureVariable(CapturedVar, C->getLocation());
12735 }
12736
12737 return S;
12738}
12739
12740template<typename Derived>
12741ExprResult
12742TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr(
12743 CXXUnresolvedConstructExpr *E) {
12744 TypeSourceInfo *T =
12745 getDerived().TransformTypeWithDeducedTST(E->getTypeSourceInfo());
12746 if (!T)
12747 return ExprError();
12748
12749 bool ArgumentChanged = false;
12750 SmallVector<Expr*, 8> Args;
12751 Args.reserve(E->getNumArgs());
12752 {
12753 EnterExpressionEvaluationContext Context(
12754 getSema(), EnterExpressionEvaluationContext::InitList,
12755 E->isListInitialization());
12756 if (getDerived().TransformExprs(E->arg_begin(), E->getNumArgs(), true, Args,
12757 &ArgumentChanged))
12758 return ExprError();
12759 }
12760
12761 if (!getDerived().AlwaysRebuild() &&
12762 T == E->getTypeSourceInfo() &&
12763 !ArgumentChanged)
12764 return E;
12765
12766 // FIXME: we're faking the locations of the commas
12767 return getDerived().RebuildCXXUnresolvedConstructExpr(
12768 T, E->getLParenLoc(), Args, E->getRParenLoc(), E->isListInitialization());
12769}
12770
12771template<typename Derived>
12772ExprResult
12773TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr(
12774 CXXDependentScopeMemberExpr *E) {
12775 // Transform the base of the expression.
12776 ExprResult Base((Expr*) nullptr);
12777 Expr *OldBase;
12778 QualType BaseType;
12779 QualType ObjectType;
12780 if (!E->isImplicitAccess()) {
12781 OldBase = E->getBase();
12782 Base = getDerived().TransformExpr(OldBase);
12783 if (Base.isInvalid())
12784 return ExprError();
12785
12786 // Start the member reference and compute the object's type.
12787 ParsedType ObjectTy;
12788 bool MayBePseudoDestructor = false;
12789 Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(),
12790 E->getOperatorLoc(),
12791 E->isArrow()? tok::arrow : tok::period,
12792 ObjectTy,
12793 MayBePseudoDestructor);
12794 if (Base.isInvalid())
12795 return ExprError();
12796
12797 ObjectType = ObjectTy.get();
12798 BaseType = ((Expr*) Base.get())->getType();
12799 } else {
12800 OldBase = nullptr;
12801 BaseType = getDerived().TransformType(E->getBaseType());
12802 ObjectType = BaseType->castAs<PointerType>()->getPointeeType();
12803 }
12804
12805 // Transform the first part of the nested-name-specifier that qualifies
12806 // the member name.
12807 NamedDecl *FirstQualifierInScope
12808 = getDerived().TransformFirstQualifierInScope(
12809 E->getFirstQualifierFoundInScope(),
12810 E->getQualifierLoc().getBeginLoc());
12811
12812 NestedNameSpecifierLoc QualifierLoc;
12813 if (E->getQualifier()) {
12814 QualifierLoc
12815 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(),
12816 ObjectType,
12817 FirstQualifierInScope);
12818 if (!QualifierLoc)
12819 return ExprError();
12820 }
12821
12822 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
12823
12824 // TODO: If this is a conversion-function-id, verify that the
12825 // destination type name (if present) resolves the same way after
12826 // instantiation as it did in the local scope.
12827
12828 DeclarationNameInfo NameInfo
12829 = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo());
12830 if (!NameInfo.getName())
12831 return ExprError();
12832
12833 if (!E->hasExplicitTemplateArgs()) {
12834 // This is a reference to a member without an explicitly-specified
12835 // template argument list. Optimize for this common case.
12836 if (!getDerived().AlwaysRebuild() &&
12837 Base.get() == OldBase &&
12838 BaseType == E->getBaseType() &&
12839 QualifierLoc == E->getQualifierLoc() &&
12840 NameInfo.getName() == E->getMember() &&
12841 FirstQualifierInScope == E->getFirstQualifierFoundInScope())
12842 return E;
12843
12844 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
12845 BaseType,
12846 E->isArrow(),
12847 E->getOperatorLoc(),
12848 QualifierLoc,
12849 TemplateKWLoc,
12850 FirstQualifierInScope,
12851 NameInfo,
12852 /*TemplateArgs*/nullptr);
12853 }
12854
12855 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
12856 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
12857 E->getNumTemplateArgs(),
12858 TransArgs))
12859 return ExprError();
12860
12861 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
12862 BaseType,
12863 E->isArrow(),
12864 E->getOperatorLoc(),
12865 QualifierLoc,
12866 TemplateKWLoc,
12867 FirstQualifierInScope,
12868 NameInfo,
12869 &TransArgs);
12870}
12871
12872template<typename Derived>
12873ExprResult
12874TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) {
12875 // Transform the base of the expression.
12876 ExprResult Base((Expr*) nullptr);
12877 QualType BaseType;
12878 if (!Old->isImplicitAccess()) {
12879 Base = getDerived().TransformExpr(Old->getBase());
12880 if (Base.isInvalid())
12881 return ExprError();
12882 Base = getSema().PerformMemberExprBaseConversion(Base.get(),
12883 Old->isArrow());
12884 if (Base.isInvalid())
12885 return ExprError();
12886 BaseType = Base.get()->getType();
12887 } else {
12888 BaseType = getDerived().TransformType(Old->getBaseType());
12889 }
12890
12891 NestedNameSpecifierLoc QualifierLoc;
12892 if (Old->getQualifierLoc()) {
12893 QualifierLoc
12894 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
12895 if (!QualifierLoc)
12896 return ExprError();
12897 }
12898
12899 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
12900
12901 LookupResult R(SemaRef, Old->getMemberNameInfo(),
12902 Sema::LookupOrdinaryName);
12903
12904 // Transform the declaration set.
12905 if (TransformOverloadExprDecls(Old, /*RequiresADL*/false, R))
12906 return ExprError();
12907
12908 // Determine the naming class.
12909 if (Old->getNamingClass()) {
12910 CXXRecordDecl *NamingClass
12911 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
12912 Old->getMemberLoc(),
12913 Old->getNamingClass()));
12914 if (!NamingClass)
12915 return ExprError();
12916
12917 R.setNamingClass(NamingClass);
12918 }
12919
12920 TemplateArgumentListInfo TransArgs;
12921 if (Old->hasExplicitTemplateArgs()) {
12922 TransArgs.setLAngleLoc(Old->getLAngleLoc());
12923 TransArgs.setRAngleLoc(Old->getRAngleLoc());
12924 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
12925 Old->getNumTemplateArgs(),
12926 TransArgs))
12927 return ExprError();
12928 }
12929
12930 // FIXME: to do this check properly, we will need to preserve the
12931 // first-qualifier-in-scope here, just in case we had a dependent
12932 // base (and therefore couldn't do the check) and a
12933 // nested-name-qualifier (and therefore could do the lookup).
12934 NamedDecl *FirstQualifierInScope = nullptr;
12935
12936 return getDerived().RebuildUnresolvedMemberExpr(Base.get(),
12937 BaseType,
12938 Old->getOperatorLoc(),
12939 Old->isArrow(),
12940 QualifierLoc,
12941 TemplateKWLoc,
12942 FirstQualifierInScope,
12943 R,
12944 (Old->hasExplicitTemplateArgs()
12945 ? &TransArgs : nullptr));
12946}
12947
12948template<typename Derived>
12949ExprResult
12950TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) {
12951 EnterExpressionEvaluationContext Unevaluated(
12952 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
12953 ExprResult SubExpr = getDerived().TransformExpr(E->getOperand());
12954 if (SubExpr.isInvalid())
12955 return ExprError();
12956
12957 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand())
12958 return E;
12959
12960 return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get());
12961}
12962
12963template<typename Derived>
12964ExprResult
12965TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) {
12966 ExprResult Pattern = getDerived().TransformExpr(E->getPattern());
12967 if (Pattern.isInvalid())
12968 return ExprError();
12969
12970 if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern())
12971 return E;
12972
12973 return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(),
12974 E->getNumExpansions());
12975}
12976
12977template<typename Derived>
12978ExprResult
12979TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) {
12980 // If E is not value-dependent, then nothing will change when we transform it.
12981 // Note: This is an instantiation-centric view.
12982 if (!E->isValueDependent())
12983 return E;
12984
12985 EnterExpressionEvaluationContext Unevaluated(
12986 getSema(), Sema::ExpressionEvaluationContext::Unevaluated);
12987
12988 ArrayRef<TemplateArgument> PackArgs;
12989 TemplateArgument ArgStorage;
12990
12991 // Find the argument list to transform.
12992 if (E->isPartiallySubstituted()) {
12993 PackArgs = E->getPartialArguments();
12994 } else if (E->isValueDependent()) {
12995 UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc());
12996 bool ShouldExpand = false;
12997 bool RetainExpansion = false;
12998 Optional<unsigned> NumExpansions;
12999 if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(),
13000 Unexpanded,
13001 ShouldExpand, RetainExpansion,
13002 NumExpansions))
13003 return ExprError();
13004
13005 // If we need to expand the pack, build a template argument from it and
13006 // expand that.
13007 if (ShouldExpand) {
13008 auto *Pack = E->getPack();
13009 if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Pack)) {
13010 ArgStorage = getSema().Context.getPackExpansionType(
13011 getSema().Context.getTypeDeclType(TTPD), None);
13012 } else if (auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Pack)) {
13013 ArgStorage = TemplateArgument(TemplateName(TTPD), None);
13014 } else {
13015 auto *VD = cast<ValueDecl>(Pack);
13016 ExprResult DRE = getSema().BuildDeclRefExpr(
13017 VD, VD->getType().getNonLValueExprType(getSema().Context),
13018 VD->getType()->isReferenceType() ? VK_LValue : VK_RValue,
13019 E->getPackLoc());
13020 if (DRE.isInvalid())
13021 return ExprError();
13022 ArgStorage = new (getSema().Context) PackExpansionExpr(
13023 getSema().Context.DependentTy, DRE.get(), E->getPackLoc(), None);
13024 }
13025 PackArgs = ArgStorage;
13026 }
13027 }
13028
13029 // If we're not expanding the pack, just transform the decl.
13030 if (!PackArgs.size()) {
13031 auto *Pack = cast_or_null<NamedDecl>(
13032 getDerived().TransformDecl(E->getPackLoc(), E->getPack()));
13033 if (!Pack)
13034 return ExprError();
13035 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), Pack,
13036 E->getPackLoc(),
13037 E->getRParenLoc(), None, None);
13038 }
13039
13040 // Try to compute the result without performing a partial substitution.
13041 Optional<unsigned> Result = 0;
13042 for (const TemplateArgument &Arg : PackArgs) {
13043 if (!Arg.isPackExpansion()) {
13044 Result = *Result + 1;
13045 continue;
13046 }
13047
13048 TemplateArgumentLoc ArgLoc;
13049 InventTemplateArgumentLoc(Arg, ArgLoc);
13050
13051 // Find the pattern of the pack expansion.
13052 SourceLocation Ellipsis;
13053 Optional<unsigned> OrigNumExpansions;
13054 TemplateArgumentLoc Pattern =
13055 getSema().getTemplateArgumentPackExpansionPattern(ArgLoc, Ellipsis,
13056 OrigNumExpansions);
13057
13058 // Substitute under the pack expansion. Do not expand the pack (yet).
13059 TemplateArgumentLoc OutPattern;
13060 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
13061 if (getDerived().TransformTemplateArgument(Pattern, OutPattern,
13062 /*Uneval*/ true))
13063 return true;
13064
13065 // See if we can determine the number of arguments from the result.
13066 Optional<unsigned> NumExpansions =
13067 getSema().getFullyPackExpandedSize(OutPattern.getArgument());
13068 if (!NumExpansions) {
13069 // No: we must be in an alias template expansion, and we're going to need
13070 // to actually expand the packs.
13071 Result = None;
13072 break;
13073 }
13074
13075 Result = *Result + *NumExpansions;
13076 }
13077
13078 // Common case: we could determine the number of expansions without
13079 // substituting.
13080 if (Result)
13081 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
13082 E->getPackLoc(),
13083 E->getRParenLoc(), *Result, None);
13084
13085 TemplateArgumentListInfo TransformedPackArgs(E->getPackLoc(),
13086 E->getPackLoc());
13087 {
13088 TemporaryBase Rebase(*this, E->getPackLoc(), getBaseEntity());
13089 typedef TemplateArgumentLocInventIterator<
13090 Derived, const TemplateArgument*> PackLocIterator;
13091 if (TransformTemplateArguments(PackLocIterator(*this, PackArgs.begin()),
13092 PackLocIterator(*this, PackArgs.end()),
13093 TransformedPackArgs, /*Uneval*/true))
13094 return ExprError();
13095 }
13096
13097 // Check whether we managed to fully-expand the pack.
13098 // FIXME: Is it possible for us to do so and not hit the early exit path?
13099 SmallVector<TemplateArgument, 8> Args;
13100 bool PartialSubstitution = false;
13101 for (auto &Loc : TransformedPackArgs.arguments()) {
13102 Args.push_back(Loc.getArgument());
13103 if (Loc.getArgument().isPackExpansion())
13104 PartialSubstitution = true;
13105 }
13106
13107 if (PartialSubstitution)
13108 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
13109 E->getPackLoc(),
13110 E->getRParenLoc(), None, Args);
13111
13112 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
13113 E->getPackLoc(), E->getRParenLoc(),
13114 Args.size(), None);
13115}
13116
13117template<typename Derived>
13118ExprResult
13119TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr(
13120 SubstNonTypeTemplateParmPackExpr *E) {
13121 // Default behavior is to do nothing with this transformation.
13122 return E;
13123}
13124
13125template<typename Derived>
13126ExprResult
13127TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr(
13128 SubstNonTypeTemplateParmExpr *E) {
13129 // Default behavior is to do nothing with this transformation.
13130 return E;
13131}
13132
13133template<typename Derived>
13134ExprResult
13135TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) {
13136 // Default behavior is to do nothing with this transformation.
13137 return E;
13138}
13139
13140template<typename Derived>
13141ExprResult
13142TreeTransform<Derived>::TransformMaterializeTemporaryExpr(
13143 MaterializeTemporaryExpr *E) {
13144 return getDerived().TransformExpr(E->getSubExpr());
13145}
13146
13147template<typename Derived>
13148ExprResult
13149TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) {
13150 UnresolvedLookupExpr *Callee = nullptr;
13151 if (Expr *OldCallee = E->getCallee()) {
13152 ExprResult CalleeResult = getDerived().TransformExpr(OldCallee);
13153 if (CalleeResult.isInvalid())
13154 return ExprError();
13155 Callee = cast<UnresolvedLookupExpr>(CalleeResult.get());
13156 }
13157
13158 Expr *Pattern = E->getPattern();
13159
13160 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
13161 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
13162 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
13163
13164 // Determine whether the set of unexpanded parameter packs can and should
13165 // be expanded.
13166 bool Expand = true;
13167 bool RetainExpansion = false;
13168 Optional<unsigned> OrigNumExpansions = E->getNumExpansions(),
13169 NumExpansions = OrigNumExpansions;
13170 if (getDerived().TryExpandParameterPacks(E->getEllipsisLoc(),
13171 Pattern->getSourceRange(),
13172 Unexpanded,
13173 Expand, RetainExpansion,
13174 NumExpansions))
13175 return true;
13176
13177 if (!Expand) {
13178 // Do not expand any packs here, just transform and rebuild a fold
13179 // expression.
13180 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
13181
13182 ExprResult LHS =
13183 E->getLHS() ? getDerived().TransformExpr(E->getLHS()) : ExprResult();
13184 if (LHS.isInvalid())
13185 return true;
13186
13187 ExprResult RHS =
13188 E->getRHS() ? getDerived().TransformExpr(E->getRHS()) : ExprResult();
13189 if (RHS.isInvalid())
13190 return true;
13191
13192 if (!getDerived().AlwaysRebuild() &&
13193 LHS.get() == E->getLHS() && RHS.get() == E->getRHS())
13194 return E;
13195
13196 return getDerived().RebuildCXXFoldExpr(
13197 Callee, E->getBeginLoc(), LHS.get(), E->getOperator(),
13198 E->getEllipsisLoc(), RHS.get(), E->getEndLoc(), NumExpansions);
13199 }
13200
13201 // Formally a fold expression expands to nested parenthesized expressions.
13202 // Enforce this limit to avoid creating trees so deep we can't safely traverse
13203 // them.
13204 if (NumExpansions && SemaRef.getLangOpts().BracketDepth < NumExpansions) {
13205 SemaRef.Diag(E->getEllipsisLoc(),
13206 clang::diag::err_fold_expression_limit_exceeded)
13207 << *NumExpansions << SemaRef.getLangOpts().BracketDepth
13208 << E->getSourceRange();
13209 SemaRef.Diag(E->getEllipsisLoc(), diag::note_bracket_depth);
13210 return ExprError();
13211 }
13212
13213 // The transform has determined that we should perform an elementwise
13214 // expansion of the pattern. Do so.
13215 ExprResult Result = getDerived().TransformExpr(E->getInit());
13216 if (Result.isInvalid())
13217 return true;
13218 bool LeftFold = E->isLeftFold();
13219
13220 // If we're retaining an expansion for a right fold, it is the innermost
13221 // component and takes the init (if any).
13222 if (!LeftFold && RetainExpansion) {
13223 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
13224
13225 ExprResult Out = getDerived().TransformExpr(Pattern);
13226 if (Out.isInvalid())
13227 return true;
13228
13229 Result = getDerived().RebuildCXXFoldExpr(
13230 Callee, E->getBeginLoc(), Out.get(), E->getOperator(),
13231 E->getEllipsisLoc(), Result.get(), E->getEndLoc(), OrigNumExpansions);
13232 if (Result.isInvalid())
13233 return true;
13234 }
13235
13236 for (unsigned I = 0; I != *NumExpansions; ++I) {
13237 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(
13238 getSema(), LeftFold ? I : *NumExpansions - I - 1);
13239 ExprResult Out = getDerived().TransformExpr(Pattern);
13240 if (Out.isInvalid())
13241 return true;
13242
13243 if (Out.get()->containsUnexpandedParameterPack()) {
13244 // We still have a pack; retain a pack expansion for this slice.
13245 Result = getDerived().RebuildCXXFoldExpr(
13246 Callee, E->getBeginLoc(), LeftFold ? Result.get() : Out.get(),
13247 E->getOperator(), E->getEllipsisLoc(),
13248 LeftFold ? Out.get() : Result.get(), E->getEndLoc(),
13249 OrigNumExpansions);
13250 } else if (Result.isUsable()) {
13251 // We've got down to a single element; build a binary operator.
13252 Expr *LHS = LeftFold ? Result.get() : Out.get();
13253 Expr *RHS = LeftFold ? Out.get() : Result.get();
13254 if (Callee)
13255 Result = getDerived().RebuildCXXOperatorCallExpr(
13256 BinaryOperator::getOverloadedOperator(E->getOperator()),
13257 E->getEllipsisLoc(), Callee, LHS, RHS);
13258 else
13259 Result = getDerived().RebuildBinaryOperator(E->getEllipsisLoc(),
13260 E->getOperator(), LHS, RHS);
13261 } else
13262 Result = Out;
13263
13264 if (Result.isInvalid())
13265 return true;
13266 }
13267
13268 // If we're retaining an expansion for a left fold, it is the outermost
13269 // component and takes the complete expansion so far as its init (if any).
13270 if (LeftFold && RetainExpansion) {
13271 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
13272
13273 ExprResult Out = getDerived().TransformExpr(Pattern);
13274 if (Out.isInvalid())
13275 return true;
13276
13277 Result = getDerived().RebuildCXXFoldExpr(
13278 Callee, E->getBeginLoc(), Result.get(), E->getOperator(),
13279 E->getEllipsisLoc(), Out.get(), E->getEndLoc(), OrigNumExpansions);
13280 if (Result.isInvalid())
13281 return true;
13282 }
13283
13284 // If we had no init and an empty pack, and we're not retaining an expansion,
13285 // then produce a fallback value or error.
13286 if (Result.isUnset())
13287 return getDerived().RebuildEmptyCXXFoldExpr(E->getEllipsisLoc(),
13288 E->getOperator());
13289
13290 return Result;
13291}
13292
13293template<typename Derived>
13294ExprResult
13295TreeTransform<Derived>::TransformCXXStdInitializerListExpr(
13296 CXXStdInitializerListExpr *E) {
13297 return getDerived().TransformExpr(E->getSubExpr());
13298}
13299
13300template<typename Derived>
13301ExprResult
13302TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) {
13303 return SemaRef.MaybeBindToTemporary(E);
13304}
13305
13306template<typename Derived>
13307ExprResult
13308TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
13309 return E;
13310}
13311
13312template<typename Derived>
13313ExprResult
13314TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *E) {
13315 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
13316 if (SubExpr.isInvalid())
13317 return ExprError();
13318
13319 if (!getDerived().AlwaysRebuild() &&
13320 SubExpr.get() == E->getSubExpr())
13321 return E;
13322
13323 return getDerived().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get());
13324}
13325
13326template<typename Derived>
13327ExprResult
13328TreeTransform<Derived>::TransformObjCArrayLiteral(ObjCArrayLiteral *E) {
13329 // Transform each of the elements.
13330 SmallVector<Expr *, 8> Elements;
13331 bool ArgChanged = false;
13332 if (getDerived().TransformExprs(E->getElements(), E->getNumElements(),
13333 /*IsCall=*/false, Elements, &ArgChanged))
13334 return ExprError();
13335
13336 if (!getDerived().AlwaysRebuild() && !ArgChanged)
13337 return SemaRef.MaybeBindToTemporary(E);
13338
13339 return getDerived().RebuildObjCArrayLiteral(E->getSourceRange(),
13340 Elements.data(),
13341 Elements.size());
13342}
13343
13344template<typename Derived>
13345ExprResult
13346TreeTransform<Derived>::TransformObjCDictionaryLiteral(
13347 ObjCDictionaryLiteral *E) {
13348 // Transform each of the elements.
13349 SmallVector<ObjCDictionaryElement, 8> Elements;
13350 bool ArgChanged = false;
13351 for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
13352 ObjCDictionaryElement OrigElement = E->getKeyValueElement(I);
13353
13354 if (OrigElement.isPackExpansion()) {
13355 // This key/value element is a pack expansion.
13356 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
13357 getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded);
13358 getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded);
13359 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
13360
13361 // Determine whether the set of unexpanded parameter packs can
13362 // and should be expanded.
13363 bool Expand = true;
13364 bool RetainExpansion = false;
13365 Optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions;
13366 Optional<unsigned> NumExpansions = OrigNumExpansions;
13367 SourceRange PatternRange(OrigElement.Key->getBeginLoc(),
13368 OrigElement.Value->getEndLoc());
13369 if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc,
13370 PatternRange, Unexpanded, Expand,
13371 RetainExpansion, NumExpansions))
13372 return ExprError();
13373
13374 if (!Expand) {
13375 // The transform has determined that we should perform a simple
13376 // transformation on the pack expansion, producing another pack
13377 // expansion.
13378 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
13379 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
13380 if (Key.isInvalid())
13381 return ExprError();
13382
13383 if (Key.get() != OrigElement.Key)
13384 ArgChanged = true;
13385
13386 ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
13387 if (Value.isInvalid())
13388 return ExprError();
13389
13390 if (Value.get() != OrigElement.Value)
13391 ArgChanged = true;
13392
13393 ObjCDictionaryElement Expansion = {
13394 Key.get(), Value.get(), OrigElement.EllipsisLoc, NumExpansions
13395 };
13396 Elements.push_back(Expansion);
13397 continue;
13398 }
13399
13400 // Record right away that the argument was changed. This needs
13401 // to happen even if the array expands to nothing.
13402 ArgChanged = true;
13403
13404 // The transform has determined that we should perform an elementwise
13405 // expansion of the pattern. Do so.
13406 for (unsigned I = 0; I != *NumExpansions; ++I) {
13407 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
13408 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
13409 if (Key.isInvalid())
13410 return ExprError();
13411
13412 ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
13413 if (Value.isInvalid())
13414 return ExprError();
13415
13416 ObjCDictionaryElement Element = {
13417 Key.get(), Value.get(), SourceLocation(), NumExpansions
13418 };
13419
13420 // If any unexpanded parameter packs remain, we still have a
13421 // pack expansion.
13422 // FIXME: Can this really happen?
13423 if (Key.get()->containsUnexpandedParameterPack() ||
13424 Value.get()->containsUnexpandedParameterPack())
13425 Element.EllipsisLoc = OrigElement.EllipsisLoc;
13426
13427 Elements.push_back(Element);
13428 }
13429
13430 // FIXME: Retain a pack expansion if RetainExpansion is true.
13431
13432 // We've finished with this pack expansion.
13433 continue;
13434 }
13435
13436 // Transform and check key.
13437 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
13438 if (Key.isInvalid())
13439 return ExprError();
13440
13441 if (Key.get() != OrigElement.Key)
13442 ArgChanged = true;
13443
13444 // Transform and check value.
13445 ExprResult Value
13446 = getDerived().TransformExpr(OrigElement.Value);
13447 if (Value.isInvalid())
13448 return ExprError();
13449
13450 if (Value.get() != OrigElement.Value)
13451 ArgChanged = true;
13452
13453 ObjCDictionaryElement Element = {
13454 Key.get(), Value.get(), SourceLocation(), None
13455 };
13456 Elements.push_back(Element);
13457 }
13458
13459 if (!getDerived().AlwaysRebuild() && !ArgChanged)
13460 return SemaRef.MaybeBindToTemporary(E);
13461
13462 return getDerived().RebuildObjCDictionaryLiteral(E->getSourceRange(),
13463 Elements);
13464}
13465
13466template<typename Derived>
13467ExprResult
13468TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) {
13469 TypeSourceInfo *EncodedTypeInfo
13470 = getDerived().TransformType(E->getEncodedTypeSourceInfo());
13471 if (!EncodedTypeInfo)
13472 return ExprError();
13473
13474 if (!getDerived().AlwaysRebuild() &&
13475 EncodedTypeInfo == E->getEncodedTypeSourceInfo())
13476 return E;
13477
13478 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(),
13479 EncodedTypeInfo,
13480 E->getRParenLoc());
13481}
13482
13483template<typename Derived>
13484ExprResult TreeTransform<Derived>::
13485TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
13486 // This is a kind of implicit conversion, and it needs to get dropped
13487 // and recomputed for the same general reasons that ImplicitCastExprs
13488 // do, as well a more specific one: this expression is only valid when
13489 // it appears *immediately* as an argument expression.
13490 return getDerived().TransformExpr(E->getSubExpr());
13491}
13492
13493template<typename Derived>
13494ExprResult TreeTransform<Derived>::
13495TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
13496 TypeSourceInfo *TSInfo
13497 = getDerived().TransformType(E->getTypeInfoAsWritten());
13498 if (!TSInfo)
13499 return ExprError();
13500
13501 ExprResult Result = getDerived().TransformExpr(E->getSubExpr());
13502 if (Result.isInvalid())
13503 return ExprError();
13504
13505 if (!getDerived().AlwaysRebuild() &&
13506 TSInfo == E->getTypeInfoAsWritten() &&
13507 Result.get() == E->getSubExpr())
13508 return E;
13509
13510 return SemaRef.BuildObjCBridgedCast(E->getLParenLoc(), E->getBridgeKind(),
13511 E->getBridgeKeywordLoc(), TSInfo,
13512 Result.get());
13513}
13514
13515template <typename Derived>
13516ExprResult TreeTransform<Derived>::TransformObjCAvailabilityCheckExpr(
13517 ObjCAvailabilityCheckExpr *E) {
13518 return E;
13519}
13520
13521template<typename Derived>
13522ExprResult
13523TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) {
13524 // Transform arguments.
13525 bool ArgChanged = false;
13526 SmallVector<Expr*, 8> Args;
13527 Args.reserve(E->getNumArgs());
13528 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), false, Args,
13529 &ArgChanged))
13530 return ExprError();
13531
13532 if (E->getReceiverKind() == ObjCMessageExpr::Class) {
13533 // Class message: transform the receiver type.
13534 TypeSourceInfo *ReceiverTypeInfo
13535 = getDerived().TransformType(E->getClassReceiverTypeInfo());
13536 if (!ReceiverTypeInfo)
13537 return ExprError();
13538
13539 // If nothing changed, just retain the existing message send.
13540 if (!getDerived().AlwaysRebuild() &&
13541 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged)
13542 return SemaRef.MaybeBindToTemporary(E);
13543
13544 // Build a new class message send.
13545 SmallVector<SourceLocation, 16> SelLocs;
13546 E->getSelectorLocs(SelLocs);
13547 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo,
13548 E->getSelector(),
13549 SelLocs,
13550 E->getMethodDecl(),
13551 E->getLeftLoc(),
13552 Args,
13553 E->getRightLoc());
13554 }
13555 else if (E->getReceiverKind() == ObjCMessageExpr::SuperClass ||
13556 E->getReceiverKind() == ObjCMessageExpr::SuperInstance) {
13557 if (!E->getMethodDecl())
13558 return ExprError();
13559
13560 // Build a new class message send to 'super'.
13561 SmallVector<SourceLocation, 16> SelLocs;
13562 E->getSelectorLocs(SelLocs);
13563 return getDerived().RebuildObjCMessageExpr(E->getSuperLoc(),
13564 E->getSelector(),
13565 SelLocs,
13566 E->getReceiverType(),
13567 E->getMethodDecl(),
13568 E->getLeftLoc(),
13569 Args,
13570 E->getRightLoc());
13571 }
13572
13573 // Instance message: transform the receiver
13574 assert(E->getReceiverKind() == ObjCMessageExpr::Instance &&
13575 "Only class and instance messages may be instantiated");
13576 ExprResult Receiver
13577 = getDerived().TransformExpr(E->getInstanceReceiver());
13578 if (Receiver.isInvalid())
13579 return ExprError();
13580
13581 // If nothing changed, just retain the existing message send.
13582 if (!getDerived().AlwaysRebuild() &&
13583 Receiver.get() == E->getInstanceReceiver() && !ArgChanged)
13584 return SemaRef.MaybeBindToTemporary(E);
13585
13586 // Build a new instance message send.
13587 SmallVector<SourceLocation, 16> SelLocs;
13588 E->getSelectorLocs(SelLocs);
13589 return getDerived().RebuildObjCMessageExpr(Receiver.get(),
13590 E->getSelector(),
13591 SelLocs,
13592 E->getMethodDecl(),
13593 E->getLeftLoc(),
13594 Args,
13595 E->getRightLoc());
13596}
13597
13598template<typename Derived>
13599ExprResult
13600TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) {
13601 return E;
13602}
13603
13604template<typename Derived>
13605ExprResult
13606TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) {
13607 return E;
13608}
13609
13610template<typename Derived>
13611ExprResult
13612TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) {
13613 // Transform the base expression.
13614 ExprResult Base = getDerived().TransformExpr(E->getBase());
13615 if (Base.isInvalid())
13616 return ExprError();
13617
13618 // We don't need to transform the ivar; it will never change.
13619
13620 // If nothing changed, just retain the existing expression.
13621 if (!getDerived().AlwaysRebuild() &&
13622 Base.get() == E->getBase())
13623 return E;
13624
13625 return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(),
13626 E->getLocation(),
13627 E->isArrow(), E->isFreeIvar());
13628}
13629
13630template<typename Derived>
13631ExprResult
13632TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
13633 // 'super' and types never change. Property never changes. Just
13634 // retain the existing expression.
13635 if (!E->isObjectReceiver())
13636 return E;
13637
13638 // Transform the base expression.
13639 ExprResult Base = getDerived().TransformExpr(E->getBase());
13640 if (Base.isInvalid())
13641 return ExprError();
13642
13643 // We don't need to transform the property; it will never change.
13644
13645 // If nothing changed, just retain the existing expression.
13646 if (!getDerived().AlwaysRebuild() &&
13647 Base.get() == E->getBase())
13648 return E;
13649
13650 if (E->isExplicitProperty())
13651 return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
13652 E->getExplicitProperty(),
13653 E->getLocation());
13654
13655 return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
13656 SemaRef.Context.PseudoObjectTy,
13657 E->getImplicitPropertyGetter(),
13658 E->getImplicitPropertySetter(),
13659 E->getLocation());
13660}
13661
13662template<typename Derived>
13663ExprResult
13664TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
13665 // Transform the base expression.
13666 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
13667 if (Base.isInvalid())
13668 return ExprError();
13669
13670 // Transform the key expression.
13671 ExprResult Key = getDerived().TransformExpr(E->getKeyExpr());
13672 if (Key.isInvalid())
13673 return ExprError();
13674
13675 // If nothing changed, just retain the existing expression.
13676 if (!getDerived().AlwaysRebuild() &&
13677 Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr())
13678 return E;
13679
13680 return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(),
13681 Base.get(), Key.get(),
13682 E->getAtIndexMethodDecl(),
13683 E->setAtIndexMethodDecl());
13684}
13685
13686template<typename Derived>
13687ExprResult
13688TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) {
13689 // Transform the base expression.
13690 ExprResult Base = getDerived().TransformExpr(E->getBase());
13691 if (Base.isInvalid())
13692 return ExprError();
13693
13694 // If nothing changed, just retain the existing expression.
13695 if (!getDerived().AlwaysRebuild() &&
13696 Base.get() == E->getBase())
13697 return E;
13698
13699 return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(),
13700 E->getOpLoc(),
13701 E->isArrow());
13702}
13703
13704template<typename Derived>
13705ExprResult
13706TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) {
13707 bool ArgumentChanged = false;
13708 SmallVector<Expr*, 8> SubExprs;
13709 SubExprs.reserve(E->getNumSubExprs());
13710 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false,
13711 SubExprs, &ArgumentChanged))
13712 return ExprError();
13713
13714 if (!getDerived().AlwaysRebuild() &&
13715 !ArgumentChanged)
13716 return E;
13717
13718 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(),
13719 SubExprs,
13720 E->getRParenLoc());
13721}
13722
13723template<typename Derived>
13724ExprResult
13725TreeTransform<Derived>::TransformConvertVectorExpr(ConvertVectorExpr *E) {
13726 ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr());
13727 if (SrcExpr.isInvalid())
13728 return ExprError();
13729
13730 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
13731 if (!Type)
13732 return ExprError();
13733
13734 if (!getDerived().AlwaysRebuild() &&
13735 Type == E->getTypeSourceInfo() &&
13736 SrcExpr.get() == E->getSrcExpr())
13737 return E;
13738
13739 return getDerived().RebuildConvertVectorExpr(E->getBuiltinLoc(),
13740 SrcExpr.get(), Type,
13741 E->getRParenLoc());
13742}
13743
13744template<typename Derived>
13745ExprResult
13746TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) {
13747 BlockDecl *oldBlock = E->getBlockDecl();
13748
13749 SemaRef.ActOnBlockStart(E->getCaretLocation(), /*Scope=*/nullptr);
13750 BlockScopeInfo *blockScope = SemaRef.getCurBlock();
13751
13752 blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic());
13753 blockScope->TheDecl->setBlockMissingReturnType(
13754 oldBlock->blockMissingReturnType());
13755
13756 SmallVector<ParmVarDecl*, 4> params;
13757 SmallVector<QualType, 4> paramTypes;
13758
13759 const FunctionProtoType *exprFunctionType = E->getFunctionType();
13760
13761 // Parameter substitution.
13762 Sema::ExtParameterInfoBuilder extParamInfos;
13763 if (getDerived().TransformFunctionTypeParams(
13764 E->getCaretLocation(), oldBlock->parameters(), nullptr,
13765 exprFunctionType->getExtParameterInfosOrNull(), paramTypes, &params,
13766 extParamInfos)) {
13767 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
13768 return ExprError();
13769 }
13770
13771 QualType exprResultType =
13772 getDerived().TransformType(exprFunctionType->getReturnType());
13773
13774 auto epi = exprFunctionType->getExtProtoInfo();
13775 epi.ExtParameterInfos = extParamInfos.getPointerOrNull(paramTypes.size());
13776
13777 QualType functionType =
13778 getDerived().RebuildFunctionProtoType(exprResultType, paramTypes, epi);
13779 blockScope->FunctionType = functionType;
13780
13781 // Set the parameters on the block decl.
13782 if (!params.empty())
13783 blockScope->TheDecl->setParams(params);
13784
13785 if (!oldBlock->blockMissingReturnType()) {
13786 blockScope->HasImplicitReturnType = false;
13787 blockScope->ReturnType = exprResultType;
13788 }
13789
13790 // Transform the body
13791 StmtResult body = getDerived().TransformStmt(E->getBody());
13792 if (body.isInvalid()) {
13793 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
13794 return ExprError();
13795 }
13796
13797#ifndef NDEBUG
13798 // In builds with assertions, make sure that we captured everything we
13799 // captured before.
13800 if (!SemaRef.getDiagnostics().hasErrorOccurred()) {
13801 for (const auto &I : oldBlock->captures()) {
13802 VarDecl *oldCapture = I.getVariable();
13803
13804 // Ignore parameter packs.
13805 if (oldCapture->isParameterPack())
13806 continue;
13807
13808 VarDecl *newCapture =
13809 cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(),
13810 oldCapture));
13811 assert(blockScope->CaptureMap.count(newCapture));
13812 }
13813 assert(oldBlock->capturesCXXThis() == blockScope->isCXXThisCaptured());
13814 }
13815#endif
13816
13817 return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(),
13818 /*Scope=*/nullptr);
13819}
13820
13821template<typename Derived>
13822ExprResult
13823TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) {
13824 llvm_unreachable("Cannot transform asType expressions yet");
13825}
13826
13827template<typename Derived>
13828ExprResult
13829TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *E) {
13830 bool ArgumentChanged = false;
13831 SmallVector<Expr*, 8> SubExprs;
13832 SubExprs.reserve(E->getNumSubExprs());
13833 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false,
13834 SubExprs, &ArgumentChanged))
13835 return ExprError();
13836
13837 if (!getDerived().AlwaysRebuild() &&
13838 !ArgumentChanged)
13839 return E;
13840
13841 return getDerived().RebuildAtomicExpr(E->getBuiltinLoc(), SubExprs,
13842 E->getOp(), E->getRParenLoc());
13843}
13844
13845//===----------------------------------------------------------------------===//
13846// Type reconstruction
13847//===----------------------------------------------------------------------===//
13848
13849template<typename Derived>
13850QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType,
13851 SourceLocation Star) {
13852 return SemaRef.BuildPointerType(PointeeType, Star,
13853 getDerived().getBaseEntity());
13854}
13855
13856template<typename Derived>
13857QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType,
13858 SourceLocation Star) {
13859 return SemaRef.BuildBlockPointerType(PointeeType, Star,
13860 getDerived().getBaseEntity());
13861}
13862
13863template<typename Derived>
13864QualType
13865TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType,
13866 bool WrittenAsLValue,
13867 SourceLocation Sigil) {
13868 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue,
13869 Sigil, getDerived().getBaseEntity());
13870}
13871
13872template<typename Derived>
13873QualType
13874TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType,
13875 QualType ClassType,
13876 SourceLocation Sigil) {
13877 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Sigil,
13878 getDerived().getBaseEntity());
13879}
13880
13881template<typename Derived>
13882QualType TreeTransform<Derived>::RebuildObjCTypeParamType(
13883 const ObjCTypeParamDecl *Decl,
13884 SourceLocation ProtocolLAngleLoc,
13885 ArrayRef<ObjCProtocolDecl *> Protocols,
13886 ArrayRef<SourceLocation> ProtocolLocs,
13887 SourceLocation ProtocolRAngleLoc) {
13888 return SemaRef.BuildObjCTypeParamType(Decl,
13889 ProtocolLAngleLoc, Protocols,
13890 ProtocolLocs, ProtocolRAngleLoc,
13891 /*FailOnError=*/true);
13892}
13893
13894template<typename Derived>
13895QualType TreeTransform<Derived>::RebuildObjCObjectType(
13896 QualType BaseType,
13897 SourceLocation Loc,
13898 SourceLocation TypeArgsLAngleLoc,
13899 ArrayRef<TypeSourceInfo *> TypeArgs,
13900 SourceLocation TypeArgsRAngleLoc,
13901 SourceLocation ProtocolLAngleLoc,
13902 ArrayRef<ObjCProtocolDecl *> Protocols,
13903 ArrayRef<SourceLocation> ProtocolLocs,
13904 SourceLocation ProtocolRAngleLoc) {
13905 return SemaRef.BuildObjCObjectType(BaseType, Loc, TypeArgsLAngleLoc,
13906 TypeArgs, TypeArgsRAngleLoc,
13907 ProtocolLAngleLoc, Protocols, ProtocolLocs,
13908 ProtocolRAngleLoc,
13909 /*FailOnError=*/true);
13910}
13911
13912template<typename Derived>
13913QualType TreeTransform<Derived>::RebuildObjCObjectPointerType(
13914 QualType PointeeType,
13915 SourceLocation Star) {
13916 return SemaRef.Context.getObjCObjectPointerType(PointeeType);
13917}
13918
13919template<typename Derived>
13920QualType
13921TreeTransform<Derived>::RebuildArrayType(QualType ElementType,
13922 ArrayType::ArraySizeModifier SizeMod,
13923 const llvm::APInt *Size,
13924 Expr *SizeExpr,
13925 unsigned IndexTypeQuals,
13926 SourceRange BracketsRange) {
13927 if (SizeExpr || !Size)
13928 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr,
13929 IndexTypeQuals, BracketsRange,
13930 getDerived().getBaseEntity());
13931
13932 QualType Types[] = {
13933 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy,
13934 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy,
13935 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty
13936 };
13937 const unsigned NumTypes = llvm::array_lengthof(Types);
13938 QualType SizeType;
13939 for (unsigned I = 0; I != NumTypes; ++I)
13940 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) {
13941 SizeType = Types[I];
13942 break;
13943 }
13944
13945 // Note that we can return a VariableArrayType here in the case where
13946 // the element type was a dependent VariableArrayType.
13947 IntegerLiteral *ArraySize
13948 = IntegerLiteral::Create(SemaRef.Context, *Size, SizeType,
13949 /*FIXME*/BracketsRange.getBegin());
13950 return SemaRef.BuildArrayType(ElementType, SizeMod, ArraySize,
13951 IndexTypeQuals, BracketsRange,
13952 getDerived().getBaseEntity());
13953}
13954
13955template<typename Derived>
13956QualType
13957TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType,
13958 ArrayType::ArraySizeModifier SizeMod,
13959 const llvm::APInt &Size,
13960 Expr *SizeExpr,
13961 unsigned IndexTypeQuals,
13962 SourceRange BracketsRange) {
13963 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, SizeExpr,
13964 IndexTypeQuals, BracketsRange);
13965}
13966
13967template<typename Derived>
13968QualType
13969TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType,
13970 ArrayType::ArraySizeModifier SizeMod,
13971 unsigned IndexTypeQuals,
13972 SourceRange BracketsRange) {
13973 return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, nullptr,
13974 IndexTypeQuals, BracketsRange);
13975}
13976
13977template<typename Derived>
13978QualType
13979TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType,
13980 ArrayType::ArraySizeModifier SizeMod,
13981 Expr *SizeExpr,
13982 unsigned IndexTypeQuals,
13983 SourceRange BracketsRange) {
13984 return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr,
13985 SizeExpr,
13986 IndexTypeQuals, BracketsRange);
13987}
13988
13989template<typename Derived>
13990QualType
13991TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType,
13992 ArrayType::ArraySizeModifier SizeMod,
13993 Expr *SizeExpr,
13994 unsigned IndexTypeQuals,
13995 SourceRange BracketsRange) {
13996 return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr,
13997 SizeExpr,
13998 IndexTypeQuals, BracketsRange);
13999}
14000
14001template <typename Derived>
14002QualType TreeTransform<Derived>::RebuildDependentAddressSpaceType(
14003 QualType PointeeType, Expr *AddrSpaceExpr, SourceLocation AttributeLoc) {
14004 return SemaRef.BuildAddressSpaceAttr(PointeeType, AddrSpaceExpr,
14005 AttributeLoc);
14006}
14007
14008template <typename Derived>
14009QualType
14010TreeTransform<Derived>::RebuildVectorType(QualType ElementType,
14011 unsigned NumElements,
14012 VectorType::VectorKind VecKind) {
14013 // FIXME: semantic checking!
14014 return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind);
14015}
14016
14017template <typename Derived>
14018QualType TreeTransform<Derived>::RebuildDependentVectorType(
14019 QualType ElementType, Expr *SizeExpr, SourceLocation AttributeLoc,
14020 VectorType::VectorKind VecKind) {
14021 return SemaRef.BuildVectorType(ElementType, SizeExpr, AttributeLoc);
14022}
14023
14024template<typename Derived>
14025QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType,
14026 unsigned NumElements,
14027 SourceLocation AttributeLoc) {
14028 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy),
14029 NumElements, true);
14030 IntegerLiteral *VectorSize
14031 = IntegerLiteral::Create(SemaRef.Context, numElements, SemaRef.Context.IntTy,
14032 AttributeLoc);
14033 return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc);
14034}
14035
14036template<typename Derived>
14037QualType
14038TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType,
14039 Expr *SizeExpr,
14040 SourceLocation AttributeLoc) {
14041 return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc);
14042}
14043
14044template <typename Derived>
14045QualType TreeTransform<Derived>::RebuildConstantMatrixType(
14046 QualType ElementType, unsigned NumRows, unsigned NumColumns) {
14047 return SemaRef.Context.getConstantMatrixType(ElementType, NumRows,
14048 NumColumns);
14049}
14050
14051template <typename Derived>
14052QualType TreeTransform<Derived>::RebuildDependentSizedMatrixType(
14053 QualType ElementType, Expr *RowExpr, Expr *ColumnExpr,
14054 SourceLocation AttributeLoc) {
14055 return SemaRef.BuildMatrixType(ElementType, RowExpr, ColumnExpr,
14056 AttributeLoc);
14057}
14058
14059template<typename Derived>
14060QualType TreeTransform<Derived>::RebuildFunctionProtoType(
14061 QualType T,
14062 MutableArrayRef<QualType> ParamTypes,
14063 const FunctionProtoType::ExtProtoInfo &EPI) {
14064 return SemaRef.BuildFunctionType(T, ParamTypes,
14065 getDerived().getBaseLocation(),
14066 getDerived().getBaseEntity(),
14067 EPI);
14068}
14069
14070template<typename Derived>
14071QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) {
14072 return SemaRef.Context.getFunctionNoProtoType(T);
14073}
14074
14075template<typename Derived>
14076QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(SourceLocation Loc,
14077 Decl *D) {
14078 assert(D && "no decl found");
14079 if (D->isInvalidDecl()) return QualType();
14080
14081 // FIXME: Doesn't account for ObjCInterfaceDecl!
14082 TypeDecl *Ty;
14083 if (auto *UPD = dyn_cast<UsingPackDecl>(D)) {
14084 // A valid resolved using typename pack expansion decl can have multiple
14085 // UsingDecls, but they must each have exactly one type, and it must be
14086 // the same type in every case. But we must have at least one expansion!
14087 if (UPD->expansions().empty()) {
14088 getSema().Diag(Loc, diag::err_using_pack_expansion_empty)
14089 << UPD->isCXXClassMember() << UPD;
14090 return QualType();
14091 }
14092
14093 // We might still have some unresolved types. Try to pick a resolved type
14094 // if we can. The final instantiation will check that the remaining
14095 // unresolved types instantiate to the type we pick.
14096 QualType FallbackT;
14097 QualType T;
14098 for (auto *E : UPD->expansions()) {
14099 QualType ThisT = RebuildUnresolvedUsingType(Loc, E);
14100 if (ThisT.isNull())
14101 continue;
14102 else if (ThisT->getAs<UnresolvedUsingType>())
14103 FallbackT = ThisT;
14104 else if (T.isNull())
14105 T = ThisT;
14106 else
14107 assert(getSema().Context.hasSameType(ThisT, T) &&
14108 "mismatched resolved types in using pack expansion");
14109 }
14110 return T.isNull() ? FallbackT : T;
14111 } else if (auto *Using = dyn_cast<UsingDecl>(D)) {
14112 assert(Using->hasTypename() &&
14113 "UnresolvedUsingTypenameDecl transformed to non-typename using");
14114
14115 // A valid resolved using typename decl points to exactly one type decl.
14116 assert(++Using->shadow_begin() == Using->shadow_end());
14117 Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl());
14118 } else {
14119 assert(isa<UnresolvedUsingTypenameDecl>(D) &&
14120 "UnresolvedUsingTypenameDecl transformed to non-using decl");
14121 Ty = cast<UnresolvedUsingTypenameDecl>(D);
14122 }
14123
14124 return SemaRef.Context.getTypeDeclType(Ty);
14125}
14126
14127template<typename Derived>
14128QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E,
14129 SourceLocation Loc) {
14130 return SemaRef.BuildTypeofExprType(E, Loc);
14131}
14132
14133template<typename Derived>
14134QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) {
14135 return SemaRef.Context.getTypeOfType(Underlying);
14136}
14137
14138template<typename Derived>
14139QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E,
14140 SourceLocation Loc) {
14141 return SemaRef.BuildDecltypeType(E, Loc);
14142}
14143
14144template<typename Derived>
14145QualType TreeTransform<Derived>::RebuildUnaryTransformType(QualType BaseType,
14146 UnaryTransformType::UTTKind UKind,
14147 SourceLocation Loc) {
14148 return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc);
14149}
14150
14151template<typename Derived>
14152QualType TreeTransform<Derived>::RebuildTemplateSpecializationType(
14153 TemplateName Template,
14154 SourceLocation TemplateNameLoc,
14155 TemplateArgumentListInfo &TemplateArgs) {
14156 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
14157}
14158
14159template<typename Derived>
14160QualType TreeTransform<Derived>::RebuildAtomicType(QualType ValueType,
14161 SourceLocation KWLoc) {
14162 return SemaRef.BuildAtomicType(ValueType, KWLoc);
14163}
14164
14165template<typename Derived>
14166QualType TreeTransform<Derived>::RebuildPipeType(QualType ValueType,
14167 SourceLocation KWLoc,
14168 bool isReadPipe) {
14169 return isReadPipe ? SemaRef.BuildReadPipeType(ValueType, KWLoc)
14170 : SemaRef.BuildWritePipeType(ValueType, KWLoc);
14171}
14172
14173template <typename Derived>
14174QualType TreeTransform<Derived>::RebuildExtIntType(bool IsUnsigned,
14175 unsigned NumBits,
14176 SourceLocation Loc) {
14177 llvm::APInt NumBitsAP(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy),
14178 NumBits, true);
14179 IntegerLiteral *Bits = IntegerLiteral::Create(SemaRef.Context, NumBitsAP,
14180 SemaRef.Context.IntTy, Loc);
14181 return SemaRef.BuildExtIntType(IsUnsigned, Bits, Loc);
14182}
14183
14184template <typename Derived>
14185QualType TreeTransform<Derived>::RebuildDependentExtIntType(
14186 bool IsUnsigned, Expr *NumBitsExpr, SourceLocation Loc) {
14187 return SemaRef.BuildExtIntType(IsUnsigned, NumBitsExpr, Loc);
14188}
14189
14190template<typename Derived>
14191TemplateName
14192TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
14193 bool TemplateKW,
14194 TemplateDecl *Template) {
14195 return SemaRef.Context.getQualifiedTemplateName(SS.getScopeRep(), TemplateKW,
14196 Template);
14197}
14198
14199template<typename Derived>
14200TemplateName
14201TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
14202 SourceLocation TemplateKWLoc,
14203 const IdentifierInfo &Name,
14204 SourceLocation NameLoc,
14205 QualType ObjectType,
14206 NamedDecl *FirstQualifierInScope,
14207 bool AllowInjectedClassName) {
14208 UnqualifiedId TemplateName;
14209 TemplateName.setIdentifier(&Name, NameLoc);
14210 Sema::TemplateTy Template;
14211 getSema().ActOnTemplateName(/*Scope=*/nullptr, SS, TemplateKWLoc,
14212 TemplateName, ParsedType::make(ObjectType),
14213 /*EnteringContext=*/false, Template,
14214 AllowInjectedClassName);
14215 return Template.get();
14216}
14217
14218template<typename Derived>
14219TemplateName
14220TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
14221 SourceLocation TemplateKWLoc,
14222 OverloadedOperatorKind Operator,
14223 SourceLocation NameLoc,
14224 QualType ObjectType,
14225 bool AllowInjectedClassName) {
14226 UnqualifiedId Name;
14227 // FIXME: Bogus location information.
14228 SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc };
14229 Name.setOperatorFunctionId(NameLoc, Operator, SymbolLocations);
14230 Sema::TemplateTy Template;
14231 getSema().ActOnTemplateName(
14232 /*Scope=*/nullptr, SS, TemplateKWLoc, Name, ParsedType::make(ObjectType),
14233 /*EnteringContext=*/false, Template, AllowInjectedClassName);
14234 return Template.get();
14235}
14236
14237template<typename Derived>
14238ExprResult
14239TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
14240 SourceLocation OpLoc,
14241 Expr *OrigCallee,
14242 Expr *First,
14243 Expr *Second) {
14244 Expr *Callee = OrigCallee->IgnoreParenCasts();
14245 bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus);
14246
14247 if (First->getObjectKind() == OK_ObjCProperty) {
14248 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op);
14249 if (BinaryOperator::isAssignmentOp(Opc))
14250 return SemaRef.checkPseudoObjectAssignment(/*Scope=*/nullptr, OpLoc, Opc,
14251 First, Second);
14252 ExprResult Result = SemaRef.CheckPlaceholderExpr(First);
14253 if (Result.isInvalid())
14254 return ExprError();
14255 First = Result.get();
14256 }
14257
14258 if (Second && Second->getObjectKind() == OK_ObjCProperty) {
14259 ExprResult Result = SemaRef.CheckPlaceholderExpr(Second);
14260 if (Result.isInvalid())
14261 return ExprError();
14262 Second = Result.get();
14263 }
14264
14265 // Determine whether this should be a builtin operation.
14266 if (Op == OO_Subscript) {
14267 if (!First->getType()->isOverloadableType() &&
14268 !Second->getType()->isOverloadableType())
14269 return getSema().CreateBuiltinArraySubscriptExpr(
14270 First, Callee->getBeginLoc(), Second, OpLoc);
14271 } else if (Op == OO_Arrow) {
14272 // -> is never a builtin operation.
14273 return SemaRef.BuildOverloadedArrowExpr(nullptr, First, OpLoc);
14274 } else if (Second == nullptr || isPostIncDec) {
14275 if (!First->getType()->isOverloadableType() ||
14276 (Op == OO_Amp && getSema().isQualifiedMemberAccess(First))) {
14277 // The argument is not of overloadable type, or this is an expression
14278 // of the form &Class::member, so try to create a built-in unary
14279 // operation.
14280 UnaryOperatorKind Opc
14281 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);
14282
14283 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First);
14284 }
14285 } else {
14286 if (!First->getType()->isOverloadableType() &&
14287 !Second->getType()->isOverloadableType()) {
14288 // Neither of the arguments is an overloadable type, so try to
14289 // create a built-in binary operation.
14290 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op);
14291 ExprResult Result
14292 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second);
14293 if (Result.isInvalid())
14294 return ExprError();
14295
14296 return Result;
14297 }
14298 }
14299
14300 // Compute the transformed set of functions (and function templates) to be
14301 // used during overload resolution.
14302 UnresolvedSet<16> Functions;
14303 bool RequiresADL;
14304
14305 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) {
14306 Functions.append(ULE->decls_begin(), ULE->decls_end());
14307 // If the overload could not be resolved in the template definition
14308 // (because we had a dependent argument), ADL is performed as part of
14309 // template instantiation.
14310 RequiresADL = ULE->requiresADL();
14311 } else {
14312 // If we've resolved this to a particular non-member function, just call
14313 // that function. If we resolved it to a member function,
14314 // CreateOverloaded* will find that function for us.
14315 NamedDecl *ND = cast<DeclRefExpr>(Callee)->getDecl();
14316 if (!isa<CXXMethodDecl>(ND))
14317 Functions.addDecl(ND);
14318 RequiresADL = false;
14319 }
14320
14321 // Add any functions found via argument-dependent lookup.
14322 Expr *Args[2] = { First, Second };
14323 unsigned NumArgs = 1 + (Second != nullptr);
14324
14325 // Create the overloaded operator invocation for unary operators.
14326 if (NumArgs == 1 || isPostIncDec) {
14327 UnaryOperatorKind Opc
14328 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec);
14329 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First,
14330 RequiresADL);
14331 }
14332
14333 if (Op == OO_Subscript) {
14334 SourceLocation LBrace;
14335 SourceLocation RBrace;
14336
14337 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) {
14338 DeclarationNameLoc NameLoc = DRE->getNameInfo().getInfo();
14339 LBrace = SourceLocation::getFromRawEncoding(
14340 NameLoc.CXXOperatorName.BeginOpNameLoc);
14341 RBrace = SourceLocation::getFromRawEncoding(
14342 NameLoc.CXXOperatorName.EndOpNameLoc);
14343 } else {
14344 LBrace = Callee->getBeginLoc();
14345 RBrace = OpLoc;
14346 }
14347
14348 return SemaRef.CreateOverloadedArraySubscriptExpr(LBrace, RBrace,
14349 First, Second);
14350 }
14351
14352 // Create the overloaded operator invocation for binary operators.
14353 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op);
14354 ExprResult Result = SemaRef.CreateOverloadedBinOp(
14355 OpLoc, Opc, Functions, Args[0], Args[1], RequiresADL);
14356 if (Result.isInvalid())
14357 return ExprError();
14358
14359 return Result;
14360}
14361
14362template<typename Derived>
14363ExprResult
14364TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(Expr *Base,
14365 SourceLocation OperatorLoc,
14366 bool isArrow,
14367 CXXScopeSpec &SS,
14368 TypeSourceInfo *ScopeType,
14369 SourceLocation CCLoc,
14370 SourceLocation TildeLoc,
14371 PseudoDestructorTypeStorage Destroyed) {
14372 QualType BaseType = Base->getType();
14373 if (Base->isTypeDependent() || Destroyed.getIdentifier() ||
14374 (!isArrow && !BaseType->getAs<RecordType>()) ||
14375 (isArrow && BaseType->getAs<PointerType>() &&
14376 !BaseType->castAs<PointerType>()->getPointeeType()
14377 ->template getAs<RecordType>())){
14378 // This pseudo-destructor expression is still a pseudo-destructor.
14379 return SemaRef.BuildPseudoDestructorExpr(
14380 Base, OperatorLoc, isArrow ? tok::arrow : tok::period, SS, ScopeType,
14381 CCLoc, TildeLoc, Destroyed);
14382 }
14383
14384 TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo();
14385 DeclarationName Name(SemaRef.Context.DeclarationNames.getCXXDestructorName(
14386 SemaRef.Context.getCanonicalType(DestroyedType->getType())));
14387 DeclarationNameInfo NameInfo(Name, Destroyed.getLocation());
14388 NameInfo.setNamedTypeInfo(DestroyedType);
14389
14390 // The scope type is now known to be a valid nested name specifier
14391 // component. Tack it on to the end of the nested name specifier.
14392 if (ScopeType) {
14393 if (!ScopeType->getType()->getAs<TagType>()) {
14394 getSema().Diag(ScopeType->getTypeLoc().getBeginLoc(),
14395 diag::err_expected_class_or_namespace)
14396 << ScopeType->getType() << getSema().getLangOpts().CPlusPlus;
14397 return ExprError();
14398 }
14399 SS.Extend(SemaRef.Context, SourceLocation(), ScopeType->getTypeLoc(),
14400 CCLoc);
14401 }
14402
14403 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller.
14404 return getSema().BuildMemberReferenceExpr(Base, BaseType,
14405 OperatorLoc, isArrow,
14406 SS, TemplateKWLoc,
14407 /*FIXME: FirstQualifier*/ nullptr,
14408 NameInfo,
14409 /*TemplateArgs*/ nullptr,
14410 /*S*/nullptr);
14411}
14412
14413template<typename Derived>
14414StmtResult
14415TreeTransform<Derived>::TransformCapturedStmt(CapturedStmt *S) {
14416 SourceLocation Loc = S->getBeginLoc();
14417 CapturedDecl *CD = S->getCapturedDecl();
14418 unsigned NumParams = CD->getNumParams();
14419 unsigned ContextParamPos = CD->getContextParamPosition();
14420 SmallVector<Sema::CapturedParamNameType, 4> Params;
14421 for (unsigned I = 0; I < NumParams; ++I) {
14422 if (I != ContextParamPos) {
14423 Params.push_back(
14424 std::make_pair(
14425 CD->getParam(I)->getName(),
14426 getDerived().TransformType(CD->getParam(I)->getType())));
14427 } else {
14428 Params.push_back(std::make_pair(StringRef(), QualType()));
14429 }
14430 }
14431 getSema().ActOnCapturedRegionStart(Loc, /*CurScope*/nullptr,
14432 S->getCapturedRegionKind(), Params);
14433 StmtResult Body;
14434 {
14435 Sema::CompoundScopeRAII CompoundScope(getSema());
14436 Body = getDerived().TransformStmt(S->getCapturedStmt());
14437 }
14438
14439 if (Body.isInvalid()) {
14440 getSema().ActOnCapturedRegionError();
14441 return StmtError();
14442 }
14443
14444 return getSema().ActOnCapturedRegionEnd(Body.get());
14445}
14446
14447} // end namespace clang
14448
14449#endif // LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
14450